// Type definitions for React 16.8
// Project: http://facebook.github.io/react/
// Definitions by: Asana <https://asana.com>
//                 AssureSign <http://www.assuresign.com>
//                 Microsoft <https://microsoft.com>
//                 John Reilly <https://github.com/johnnyreilly>
//                 Benoit Benezech <https://github.com/bbenezech>
//                 Patricio Zavolinsky <https://github.com/pzavolinsky>
//                 Digiguru <https://github.com/digiguru>
//                 Eric Anderson <https://github.com/ericanderson>
//                 Tanguy Krotoff <https://github.com/tkrotoff>
//                 Dovydas Navickas <https://github.com/DovydasNavickas>
//                 Stéphane Goetz <https://github.com/onigoetz>
//                 Josh Rutherford <https://github.com/theruther4d>
//                 Guilherme Hübner <https://github.com/guilhermehubner>
//                 Ferdy Budhidharma <https://github.com/ferdaber>
//                 Johann Rakotoharisoa <https://github.com/jrakotoharisoa>
//                 Olivier Pascal <https://github.com/pascaloliv>
//                 Martin Hochel <https://github.com/hotell>
//                 Frank Li <https://github.com/franklixuefei>
//                 Jessica Franco <https://github.com/Jessidhia>
//                 Paul Sherman <https://github.com/pshrmn>
//                 Saransh Kataria <https://github.com/saranshkataria>
//                 Kanitkorn Sujautra <https://github.com/lukyth>
//                 Sebastian Silbermann <https://github.com/eps1lon>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.8

/// <引用 路径="global.d.cts"/>

导入 * 转为 CSS 来自 "csstype";
导入 * 转为 PropTypes 来自 "prop-types";

//@@{ 动画事件_:AnimationEvent }
类型 NativeAnimationEvent = 动画事件_;

//@@{ 剪贴板事件_:ClipboardEvent }
类型 NativeClipboardEvent = 剪贴板事件_;

//@@{ 组件事件_:CompositionEvent }
类型 NativeCompositionEvent = 组件事件_;

//@@{ 拖拽事件_:DragEvent }
类型 NativeDragEvent = 拖拽事件_;

//@@{ 焦点事件_:FocusEvent }
类型 NativeFocusEvent = 焦点事件_;

//@@{ 键盘事件_:KeyboardEvent }
类型 NativeKeyboardEvent = 键盘事件_;

//@@{ 鼠标事件_:MouseEvent }
类型 NativeMouseEvent = 鼠标事件_;

//@@{ 触摸事件_:TouchEvent }
类型 NativeTouchEvent = 触摸事件_;

//@@{ 指针事件_:PointerEvent }
类型 NativePointerEvent = 指针事件_;

//@@{ 过渡事件_:TransitionEvent }
类型 NativeTransitionEvent = 过渡事件_;

//@@{ UI事件_:UIEvent }
类型 NativeUIEvent = UI事件_;

//@@{ 轮事件_:WheelEvent }
类型 NativeWheelEvent = 轮事件_;

/**
 * defined in scheduler/tracing
 */
接口 SchedulerInteraction {
    id: 数字;

    //@@{ 名称:name }
    名称: 文字;
    timestamp: 数字;
}

// tslint:disable-next-line:export-just-namespace
导出 = React;
导出 转为 名域 React;

声明 名域 React {
    //
    // React Elements
    // ----------------------------------------------------------------------

    类型 ElementType<P = 任意> =
        {

            //@@{ 内置元素_:IntrinsicElements }
            [K 位于 键为 JSX.内置元素_]: P 扩展 JSX.内置元素_[K] ? K : 不及

        //@@{ 内置元素_:IntrinsicElements }
        }[键为 JSX.内置元素_] |
        ComponentType<P>;
    /**
     * @deprecated Please use `ElementType`
     */
    类型 ReactType<P = 任意> = ElementType<P>;
    类型 ComponentType<P = {}> = ComponentClass<P> | FunctionComponent<P>;

    类型 JSXElementConstructor<P> =
        | ((属性组: P) => ReactElement | 空值)
        | (新建 (属性组: P) => Component<P, 任意>);

    类型 Key = 文字 | 数字;

    接口 RefObject<T> {
        只读 current: T | 空值;
    }

    类型 Ref<T> = { bivarianceHack(instance: T | 空值): 无值 }["bivarianceHack"] | RefObject<T> | 空值;
    类型 LegacyRef<T> = 文字 | Ref<T>;

    类型 ComponentState = 任意;

    接口 Attributes {
        key?: Key;
    }
    接口 RefAttributes<T> 扩展 Attributes {
        ref?: Ref<T>;
    }
    接口 ClassAttributes<T> 扩展 Attributes {
        ref?: LegacyRef<T>;
    }

    接口 ReactElement<P = 任意, T 扩展 文字 | JSXElementConstructor<任意> = 文字 | JSXElementConstructor<任意>> {

        //@@{ 类型:type }
        类型: T;

        //@@{ 属性组:props }
        属性组: P;
        key: Key | 空值;
    }

    接口 ReactComponentElement<

        //@@{ 内置元素_:IntrinsicElements }
        T 扩展 键为 JSX.内置元素_ | JSXElementConstructor<任意>,

        //@@{ 挑选_:Pick, 排除_:Exclude }
        P = 挑选_<ComponentProps<T>, 排除_<键为 ComponentProps<T>, 'key' | 'ref'>>
    > 扩展 ReactElement<P, T> { }

    /**
     * @deprecated Please use `FunctionComponentElement`
     */
    类型 SFCElement<P> = FunctionComponentElement<P>;

    接口 FunctionComponentElement<P> 扩展 ReactElement<P, FunctionComponent<P>> {
        ref?: 'ref' 扩展 键为 P ? P 扩展 { ref?: 推断 R } ? R : 不及 : 不及;
    }

    类型 CElement<P, T 扩展 Component<P, ComponentState>> = ComponentElement<P, T>;
    接口 ComponentElement<P, T 扩展 Component<P, ComponentState>> 扩展 ReactElement<P, ComponentClass<P>> {
        ref?: LegacyRef<T>;
    }

    类型 ClassicElement<P> = CElement<P, ClassicComponent<P, ComponentState>>;

    // string fallback for custom web-components

    //@@{ 元素_:Element }
    接口 DOMElement<P 扩展 HTMLAttributes<T> | SVGAttributes<T>, T 扩展 元素_> 扩展 ReactElement<P, 文字> {
        ref: LegacyRef<T>;
    }

    // ReactHTML for ReactHTMLElement
    // tslint:disable-next-line:no-empty-interface

    //@@{ HTML元素_:HTMLElement }
    接口 ReactHTMLElement<T 扩展 HTML元素_> 扩展 DetailedReactHTMLElement<AllHTMLAttributes<T>, T> { }

    //@@{ HTML元素_:HTMLElement }
    接口 DetailedReactHTMLElement<P 扩展 HTMLAttributes<T>, T 扩展 HTML元素_> 扩展 DOMElement<P, T> {

        //@@{ 类型:type }
        类型: 键为 ReactHTML;
    }

    // ReactSVG for ReactSVGElement

    //@@{ SVG元素_:SVGElement }
    接口 ReactSVGElement 扩展 DOMElement<SVGAttributes<SVG元素_>, SVG元素_> {

        //@@{ 类型:type }
        类型: 键为 ReactSVG;
    }

    接口 ReactPortal 扩展 ReactElement {
        key: Key | 空值;

        //@@{ 子属性:children }
        子属性: ReactNode;
    }

    //
    // Factories
    // ----------------------------------------------------------------------

    类型 Factory<P> = (属性组?: Attributes & P, ...子属性: ReactNode[]) => ReactElement<P>;

    /**
     * @deprecated Please use `FunctionComponentFactory`
     */
    类型 SFCFactory<P> = FunctionComponentFactory<P>;

    类型 FunctionComponentFactory<P> = (属性组?: Attributes & P, ...子属性: ReactNode[]) => FunctionComponentElement<P>;

    类型 ComponentFactory<P, T 扩展 Component<P, ComponentState>> =
        (属性组?: ClassAttributes<T> & P, ...子属性: ReactNode[]) => CElement<P, T>;

    类型 CFactory<P, T 扩展 Component<P, ComponentState>> = ComponentFactory<P, T>;
    类型 ClassicFactory<P> = CFactory<P, ClassicComponent<P, ComponentState>>;

    //@@{ 元素_:Element }
    类型 DOMFactory<P 扩展 DOMAttributes<T>, T 扩展 元素_> =
        (属性组?: ClassAttributes<T> & P | 空值, ...子属性: ReactNode[]) => DOMElement<P, T>;

    // tslint:disable-next-line:no-empty-interface

    //@@{ HTML元素_:HTMLElement }
    接口 HTMLFactory<T 扩展 HTML元素_> 扩展 DetailedHTMLFactory<AllHTMLAttributes<T>, T> {}

    //@@{ HTML元素_:HTMLElement }
    接口 DetailedHTMLFactory<P 扩展 HTMLAttributes<T>, T 扩展 HTML元素_> 扩展 DOMFactory<P, T> {
        (属性组?: ClassAttributes<T> & P | 空值, ...子属性: ReactNode[]): DetailedReactHTMLElement<P, T>;
    }

    //@@{ SVG元素_:SVGElement }
    接口 SVGFactory 扩展 DOMFactory<SVGAttributes<SVG元素_>, SVG元素_> {

        //@@{ SVG元素_:SVGElement }
        (属性组?: ClassAttributes<SVG元素_> & SVGAttributes<SVG元素_> | 空值, ...子属性: ReactNode[]): ReactSVGElement;
    }

    //
    // React Nodes
    // http://facebook.github.io/react/docs/glossary.html
    // ----------------------------------------------------------------------

    类型 ReactText = 文字 | 数字;
    类型 ReactChild = ReactElement | ReactText;

    //@@{ 数组_:Array }
    接口 ReactNodeArray 扩展 数组_<ReactNode> {}
    类型 ReactFragment = {} | ReactNodeArray;
    类型 ReactNode = ReactChild | ReactFragment | ReactPortal | 真假 | 空值 | 未定;

    //
    // Top Level API
    // ----------------------------------------------------------------------

    // DOM Elements

    //@@{ HTML元素_:HTMLElement }
    函数 createFactory<T 扩展 HTML元素_>(
        类型: 键为 ReactHTML): HTMLFactory<T>;
    函数 createFactory(
        类型: 键为 ReactSVG): SVGFactory;

    //@@{ 元素_:Element }
    函数 createFactory<P 扩展 DOMAttributes<T>, T 扩展 元素_>(
        类型: 文字): DOMFactory<P, T>;

    // Custom components
    函数 createFactory<P>(类型: FunctionComponent<P>): FunctionComponentFactory<P>;
    函数 createFactory<P>(
        类型: ClassType<P, ClassicComponent<P, ComponentState>, ClassicComponentClass<P>>): CFactory<P, ClassicComponent<P, ComponentState>>;
    函数 createFactory<P, T 扩展 Component<P, ComponentState>, C 扩展 ComponentClass<P>>(
        类型: ClassType<P, T, C>): CFactory<P, T>;
    函数 createFactory<P>(类型: ComponentClass<P>): Factory<P>;

    // DOM Elements
    // TODO: generalize this to everything in `keyof ReactHTML`, not just "input"
    函数 createElement(
        类型: "input",

        //@@{ HTML输入元素_:HTMLInputElement }
        属性组?: InputHTMLAttributes<HTML输入元素_> & ClassAttributes<HTML输入元素_> | 空值,

        //@@{ HTML输入元素_:HTMLInputElement }
        ...子属性: ReactNode[]): DetailedReactHTMLElement<InputHTMLAttributes<HTML输入元素_>, HTML输入元素_>;

    //@@{ HTML元素_:HTMLElement }
    函数 createElement<P 扩展 HTMLAttributes<T>, T 扩展 HTML元素_>(
        类型: 键为 ReactHTML,
        属性组?: ClassAttributes<T> & P | 空值,
        ...子属性: ReactNode[]): DetailedReactHTMLElement<P, T>;

    //@@{ SVG元素_:SVGElement }
    函数 createElement<P 扩展 SVGAttributes<T>, T 扩展 SVG元素_>(
        类型: 键为 ReactSVG,
        属性组?: ClassAttributes<T> & P | 空值,
        ...子属性: ReactNode[]): ReactSVGElement;

    //@@{ 元素_:Element }
    函数 createElement<P 扩展 DOMAttributes<T>, T 扩展 元素_>(
        类型: 文字,
        属性组?: ClassAttributes<T> & P | 空值,
        ...子属性: ReactNode[]): DOMElement<P, T>;

    // Custom components

    函数 createElement<P 扩展 {}>(
        类型: FunctionComponent<P>,
        属性组?: Attributes & P | 空值,
        ...子属性: ReactNode[]): FunctionComponentElement<P>;
    函数 createElement<P 扩展 {}>(
        类型: ClassType<P, ClassicComponent<P, ComponentState>, ClassicComponentClass<P>>,
        属性组?: ClassAttributes<ClassicComponent<P, ComponentState>> & P | 空值,
        ...子属性: ReactNode[]): CElement<P, ClassicComponent<P, ComponentState>>;
    函数 createElement<P 扩展 {}, T 扩展 Component<P, ComponentState>, C 扩展 ComponentClass<P>>(
        类型: ClassType<P, T, C>,
        属性组?: ClassAttributes<T> & P | 空值,
        ...子属性: ReactNode[]): CElement<P, T>;
    函数 createElement<P 扩展 {}>(
        类型: FunctionComponent<P> | ComponentClass<P> | 文字,
        属性组?: Attributes & P | 空值,
        ...子属性: ReactNode[]): ReactElement<P>;

    // DOM Elements
    // ReactHTMLElement

    //@@{ HTML元素_:HTMLElement }
    函数 cloneElement<P 扩展 HTMLAttributes<T>, T 扩展 HTML元素_>(
        元素: DetailedReactHTMLElement<P, T>,
        属性组?: P,
        ...子属性: ReactNode[]): DetailedReactHTMLElement<P, T>;
    // ReactHTMLElement, less specific

    //@@{ HTML元素_:HTMLElement }
    函数 cloneElement<P 扩展 HTMLAttributes<T>, T 扩展 HTML元素_>(
        元素: ReactHTMLElement<T>,
        属性组?: P,
        ...子属性: ReactNode[]): ReactHTMLElement<T>;
    // SVGElement

    //@@{ SVG元素_:SVGElement }
    函数 cloneElement<P 扩展 SVGAttributes<T>, T 扩展 SVG元素_>(
        元素: ReactSVGElement,
        属性组?: P,
        ...子属性: ReactNode[]): ReactSVGElement;
    // DOM Element (has to be the last, because type checking stops at first overload that fits)

    //@@{ 元素_:Element }
    函数 cloneElement<P 扩展 DOMAttributes<T>, T 扩展 元素_>(
        元素: DOMElement<P, T>,
        属性组?: DOMAttributes<T> & P,
        ...子属性: ReactNode[]): DOMElement<P, T>;

    // Custom components
    函数 cloneElement<P>(
        元素: FunctionComponentElement<P>,

        //@@{ 可选_:Partial }
        属性组?: 可选_<P> & Attributes,
        ...子属性: ReactNode[]): FunctionComponentElement<P>;
    函数 cloneElement<P, T 扩展 Component<P, ComponentState>>(
        元素: CElement<P, T>,

        //@@{ 可选_:Partial }
        属性组?: 可选_<P> & ClassAttributes<T>,
        ...子属性: ReactNode[]): CElement<P, T>;
    函数 cloneElement<P>(
        元素: ReactElement<P>,

        //@@{ 可选_:Partial }
        属性组?: 可选_<P> & Attributes,
        ...子属性: ReactNode[]): ReactElement<P>;

    // Context via RenderProps
    接口 ProviderProps<T> {

        //@@{ 值:value }
        值: T;

        //@@{ 子属性:children }
        子属性?: ReactNode;
    }

    接口 ConsumerProps<T> {

        //@@{ 子属性:children }
        子属性: (值: T) => ReactNode;
        unstable_observedBits?: 数字;
    }

    // TODO: similar to how Fragment is actually a symbol, the values returned from createContext,
    // forwardRef and memo are actually objects that are treated specially by the renderer; see:
    // https://github.com/facebook/react/blob/v16.6.0/packages/react/src/ReactContext.js#L35-L48
    // https://github.com/facebook/react/blob/v16.6.0/packages/react/src/forwardRef.js#L42-L45
    // https://github.com/facebook/react/blob/v16.6.0/packages/react/src/memo.js#L27-L31
    // However, we have no way of telling the JSX parser that it's a JSX element type or its props other than
    // by pretending to be a normal component.
    //
    // We don't just use ComponentType or SFC types because you are not supposed to attach statics to this
    // object, but rather to the original function.
    接口 ExoticComponent<P = {}> {
        /**
         * **NOTE**: Exotic components are not callable.
         */
        (属性组: P): (ReactElement|空值);
        只读 $$typeof: 符号;
    }

    接口 NamedExoticComponent<P = {}> 扩展 ExoticComponent<P> {
        displayName?: 文字;
    }

    接口 ProviderExoticComponent<P> 扩展 ExoticComponent<P> {
        propTypes?: WeakValidationMap<P>;
    }

    类型 ContextType<C 扩展 Context<任意>> = C 扩展 Context<推断 T> ? T : 不及;

    // NOTE: only the Context object itself can get a displayName
    // https://github.com/facebook/react-devtools/blob/e0b854e4c/backend/attachRendererFiber.js#L310-L325
    类型 Provider<T> = ProviderExoticComponent<ProviderProps<T>>;
    类型 Consumer<T> = ExoticComponent<ConsumerProps<T>>;
    接口 Context<T> {
        Provider: Provider<T>;
        Consumer: Consumer<T>;
        displayName?: 文字;
    }
    函数 createContext<T>(
        defaultValue: T,
        calculateChangedBits?: (prev: T, 下个: T) => 数字
    ): Context<T>;

    函数 isValidElement<P>(对象: {} | 空值 | 未定): 对象 作为 ReactElement<P>;

    常量 Children: ReactChildren;

    //@@{ 子属性:children }
    常量 Fragment: ExoticComponent<{ 子属性?: ReactNode }>;

    //@@{ 子属性:children }
    常量 StrictMode: ExoticComponent<{ 子属性?: ReactNode }>;

    接口 SuspenseProps {

        //@@{ 子属性:children }
        子属性?: ReactNode;

        /** A fallback react tree to show when a Suspense child (like React.lazy) suspends */

        //@@{ 非可空_:NonNullable }
        fallback: 非可空_<ReactNode>|空值;

        // I tried looking at the code but I have no idea what it does.
        // https://github.com/facebook/react/issues/13206#issuecomment-432489986
        /**
         * Not implemented yet, requires unstable_ConcurrentMode
         */
        // maxDuration?: number;
    }
    /**
     * This feature is not yet available for server-side rendering.
     * Suspense support will be added in a later release.
     */
    常量 Suspense: ExoticComponent<SuspenseProps>;
    常量 version: 文字;

    /**
     * {@link https://github.com/bvaughn/rfcs/blob/profiler/text/0000-profiler.md#detailed-design | API}
     */
    类型 ProfilerOnRenderCallback = (
        id: 文字,
        phase: "mount" | "update",
        actualDuration: 数字,
        baseDuration: 数字,
        startTime: 数字,
        commitTime: 数字,

        //@@{ 集合_:Set }
        interactions: 集合_<SchedulerInteraction>,
    ) => 无值;
    接口 ProfilerProps {

        //@@{ 子属性:children }
        子属性?: ReactNode;
        id: 文字;
        onRender: ProfilerOnRenderCallback;
    }

    常量 unstable_Profiler: ExoticComponent<ProfilerProps>;

    //
    // Component API
    // ----------------------------------------------------------------------

    //@@{ 元素_:Element }
    类型 ReactInstance = Component<任意> | 元素_;

    // Base component for plain JS classes
    // tslint:disable-next-line:no-empty-interface
    接口 Component<P = {}, S = {}, SS = 任意> 扩展 ComponentLifecycle<P, S, SS> { }
    类别 Component<P, S> {
        // tslint won't let me format the sample code in a way that vscode likes it :(
        /**
         * If set, `this.context` will be set at runtime to the current value of the given Context.
         *
         * Usage:
         *
         * ```ts
         * type MyContext = number
         * const Ctx = React.createContext<MyContext>(0)
         *
         * class Foo extends React.Component {
         *   static contextType = Ctx
         *   context!: React.ContextType<typeof Ctx>
         *   render () {
         *     return <>My context's value: {this.context}</>;
         *   }
         * }
         * ```
         *
         * @see https://reactjs.org/docs/context.html#classcontexttype
         */
        静态 contextType?: Context<任意>;

        /**
         * If using the new style context, re-declare this in your class to be the
         * `React.ContextType` of your `static contextType`.
         *
         * ```ts
         * static contextType = MyContext
         * context!: React.ContextType<typeof MyContext>
         * ```
         *
         * @deprecated if used without a type annotation, or without static contextType
         * @see https://reactjs.org/docs/legacy-context.html
         */
        // TODO (TypeScript 3.0): unknown
        context: 任意;

        //@@{ 只读_:Readonly }
        构造(属性组: 只读_<P>);
        /**
         * @deprecated
         * @see https://reactjs.org/docs/legacy-context.html
         */
        构造(属性组: P, context?: 任意);

        // We MUST keep setState() as a unified signature because it allows proper checking of the method return type.
        // See: https://github.com/DefinitelyTyped/DefinitelyTyped/issues/18365#issuecomment-351013257
        // Also, the ` | S` allows intellisense to not be dumbisense
        setState<K 扩展 键为 S>(

            //@@{ 只读_:Readonly, 挑选_:Pick }
            state: ((prevState: 只读_<S>, 属性组: 只读_<P>) => (挑选_<S, K> | S | 空值)) | (挑选_<S, K> | S | 空值),
            callback?: () => 无值
        ): 无值;

        forceUpdate(callBack?: () => 无值): 无值;
        render(): ReactNode;

        // React.Props<T> is now deprecated, which means that the `children`
        // property is not available on `P` by default, even though you can
        // always pass children as variadic arguments to `createElement`.
        // In the future, if we can define its call signature conditionally
        // on the existence of `children` in `P`, then we should remove this.

        //@@{ 属性组:props, 只读_:Readonly, 子属性:children }
        只读 属性组: 只读_<P> & 只读_<{ 子属性?: ReactNode }>;

        //@@{ 只读_:Readonly }
        state: 只读_<S>;
        /**
         * @deprecated
         * https://reactjs.org/docs/refs-and-the-dom.html#legacy-api-string-refs
         */
        refs: {
            [key: 文字]: ReactInstance
        };
    }

    类别 PureComponent<P = {}, S = {}, SS = 任意> 扩展 Component<P, S, SS> { }

    接口 ClassicComponent<P = {}, S = {}> 扩展 Component<P, S> {
        replaceState(nextState: S, callback?: () => 无值): 无值;
        isMounted(): 真假;
        getInitialState?(): S;
    }

    接口 ChildContextProvider<CC> {
        getChildContext(): CC;
    }

    //
    // Class Interfaces
    // ----------------------------------------------------------------------

    /**
     * @deprecated as of recent React versions, function components can no
     * longer be considered 'stateless'. Please use `FunctionComponent` instead.
     *
     * @see [React Hooks](https://reactjs.org/docs/hooks-intro.html)
     */
    类型 SFC<P = {}> = FunctionComponent<P>;

    /**
     * @deprecated as of recent React versions, function components can no
     * longer be considered 'stateless'. Please use `FunctionComponent` instead.
     *
     * @see [React Hooks](https://reactjs.org/docs/hooks-intro.html)
     */
    类型 StatelessComponent<P = {}> = FunctionComponent<P>;

    类型 FC<P = {}> = FunctionComponent<P>;

    接口 FunctionComponent<P = {}> {
        (属性组: PropsWithChildren<P>, context?: 任意): ReactElement | 空值;
        propTypes?: WeakValidationMap<P>;
        contextTypes?: ValidationMap<任意>;

        //@@{ 可选_:Partial }
        defaultProps?: 可选_<P>;
        displayName?: 文字;
    }

    接口 RefForwardingComponent<T, P = {}> {
        (属性组: PropsWithChildren<P>, ref: Ref<T>): ReactElement | 空值;
        propTypes?: WeakValidationMap<P>;
        contextTypes?: ValidationMap<任意>;

        //@@{ 可选_:Partial }
        defaultProps?: 可选_<P>;
        displayName?: 文字;
    }

    接口 ComponentClass<P = {}, S = ComponentState> 扩展 StaticLifecycle<P, S> {
        新建 (属性组: P, context?: 任意): Component<P, S>;
        propTypes?: WeakValidationMap<P>;
        contextType?: Context<任意>;
        contextTypes?: ValidationMap<任意>;
        childContextTypes?: ValidationMap<任意>;

        //@@{ 可选_:Partial }
        defaultProps?: 可选_<P>;
        displayName?: 文字;
    }

    接口 ClassicComponentClass<P = {}> 扩展 ComponentClass<P> {
        新建 (属性组: P, context?: 任意): ClassicComponent<P, ComponentState>;
        getDefaultProps?(): P;
    }

    /**
     * We use an intersection type to infer multiple type parameters from
     * a single argument, which is useful for many top-level API defs.
     * See https://github.com/Microsoft/TypeScript/issues/7234 for more info.
     */
    类型 ClassType<P, T 扩展 Component<P, ComponentState>, C 扩展 ComponentClass<P>> =
        C &
        (新建 (属性组: P, context?: 任意) => T);

    //
    // Component Specs and Lifecycle
    // ----------------------------------------------------------------------

    // This should actually be something like `Lifecycle<P, S> | DeprecatedLifecycle<P, S>`,
    // as React will _not_ call the deprecated lifecycle methods if any of the new lifecycle
    // methods are present.
    接口 ComponentLifecycle<P, S, SS = 任意> 扩展 NewLifecycle<P, S, SS>, DeprecatedLifecycle<P, S> {
        /**
         * Called immediately after a component is mounted. Setting state here will trigger re-rendering.
         */
        componentDidMount?(): 无值;
        /**
         * Called to determine whether the change in props and state should trigger a re-render.
         *
         * `Component` always returns true.
         * `PureComponent` implements a shallow comparison on props and state and returns true if any
         * props or states have changed.
         *
         * If false is returned, `Component#render`, `componentWillUpdate`
         * and `componentDidUpdate` will not be called.
         */

        //@@{ 只读_:Readonly }
        shouldComponentUpdate?(nextProps: 只读_<P>, nextState: 只读_<S>, nextContext: 任意): 真假;
        /**
         * Called immediately before a component is destroyed. Perform any necessary cleanup in this method, such as
         * cancelled network requests, or cleaning up any DOM elements created in `componentDidMount`.
         */
        componentWillUnmount?(): 无值;
        /**
         * Catches exceptions generated in descendant components. Unhandled exceptions will cause
         * the entire component tree to unmount.
         */

        //@@{ 错误_:Error }
        componentDidCatch?(error: 错误_, errorInfo: ErrorInfo): 无值;
    }

    // Unfortunately, we have no way of declaring that the component constructor must implement this
    接口 StaticLifecycle<P, S> {
        getDerivedStateFromProps?: GetDerivedStateFromProps<P, S>;
        getDerivedStateFromError?: GetDerivedStateFromError<P, S>;
    }

    类型 GetDerivedStateFromProps<P, S> =
        /**
         * Returns an update to a component's state based on its new props and old state.
         *
         * Note: its presence prevents any of the deprecated lifecycle methods from being invoked
         */

        //@@{ 只读_:Readonly, 可选_:Partial }
        (nextProps: 只读_<P>, prevState: S) => 可选_<S> | 空值;

    类型 GetDerivedStateFromError<P, S> =
        /**
         * This lifecycle is invoked after an error has been thrown by a descendant component.
         * It receives the error that was thrown as a parameter and should return a value to update state.
         *
         * Note: its presence prevents any of the deprecated lifecycle methods from being invoked
         */

        //@@{ 可选_:Partial }
        (error: 任意) => 可选_<S> | 空值;

    // This should be "infer SS" but can't use it yet
    接口 NewLifecycle<P, S, SS> {
        /**
         * Runs before React applies the result of `render` to the document, and
         * returns an object to be given to componentDidUpdate. Useful for saving
         * things such as scroll position before `render` causes changes to it.
         *
         * Note: the presence of getSnapshotBeforeUpdate prevents any of the deprecated
         * lifecycle events from running.
         */

        //@@{ 只读_:Readonly }
        getSnapshotBeforeUpdate?(prevProps: 只读_<P>, prevState: 只读_<S>): SS | 空值;
        /**
         * Called immediately after updating occurs. Not called for the initial render.
         *
         * The snapshot is only present if getSnapshotBeforeUpdate is present and returns non-null.
         */

        //@@{ 只读_:Readonly }
        componentDidUpdate?(prevProps: 只读_<P>, prevState: 只读_<S>, snapshot?: SS): 无值;
    }

    接口 DeprecatedLifecycle<P, S> {
        /**
         * Called immediately before mounting occurs, and before `Component#render`.
         * Avoid introducing any side-effects or subscriptions in this method.
         *
         * Note: the presence of getSnapshotBeforeUpdate or getDerivedStateFromProps
         * prevents this from being invoked.
         *
         * @deprecated 16.3, use componentDidMount or the constructor instead; will stop working in React 17
         * @see https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#initializing-state
         * @see https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#gradual-migration-path
         */
        componentWillMount?(): 无值;
        /**
         * Called immediately before mounting occurs, and before `Component#render`.
         * Avoid introducing any side-effects or subscriptions in this method.
         *
         * This method will not stop working in React 17.
         *
         * Note: the presence of getSnapshotBeforeUpdate or getDerivedStateFromProps
         * prevents this from being invoked.
         *
         * @deprecated 16.3, use componentDidMount or the constructor instead
         * @see https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#initializing-state
         * @see https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#gradual-migration-path
         */
        UNSAFE_componentWillMount?(): 无值;
        /**
         * Called when the component may be receiving new props.
         * React may call this even if props have not changed, so be sure to compare new and existing
         * props if you only want to handle changes.
         *
         * Calling `Component#setState` generally does not trigger this method.
         *
         * Note: the presence of getSnapshotBeforeUpdate or getDerivedStateFromProps
         * prevents this from being invoked.
         *
         * @deprecated 16.3, use static getDerivedStateFromProps instead; will stop working in React 17
         * @see https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#updating-state-based-on-props
         * @see https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#gradual-migration-path
         */

        //@@{ 只读_:Readonly }
        componentWillReceiveProps?(nextProps: 只读_<P>, nextContext: 任意): 无值;
        /**
         * Called when the component may be receiving new props.
         * React may call this even if props have not changed, so be sure to compare new and existing
         * props if you only want to handle changes.
         *
         * Calling `Component#setState` generally does not trigger this method.
         *
         * This method will not stop working in React 17.
         *
         * Note: the presence of getSnapshotBeforeUpdate or getDerivedStateFromProps
         * prevents this from being invoked.
         *
         * @deprecated 16.3, use static getDerivedStateFromProps instead
         * @see https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#updating-state-based-on-props
         * @see https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#gradual-migration-path
         */

        //@@{ 只读_:Readonly }
        UNSAFE_componentWillReceiveProps?(nextProps: 只读_<P>, nextContext: 任意): 无值;
        /**
         * Called immediately before rendering when new props or state is received. Not called for the initial render.
         *
         * Note: You cannot call `Component#setState` here.
         *
         * Note: the presence of getSnapshotBeforeUpdate or getDerivedStateFromProps
         * prevents this from being invoked.
         *
         * @deprecated 16.3, use getSnapshotBeforeUpdate instead; will stop working in React 17
         * @see https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#reading-dom-properties-before-an-update
         * @see https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#gradual-migration-path
         */

        //@@{ 只读_:Readonly }
        componentWillUpdate?(nextProps: 只读_<P>, nextState: 只读_<S>, nextContext: 任意): 无值;
        /**
         * Called immediately before rendering when new props or state is received. Not called for the initial render.
         *
         * Note: You cannot call `Component#setState` here.
         *
         * This method will not stop working in React 17.
         *
         * Note: the presence of getSnapshotBeforeUpdate or getDerivedStateFromProps
         * prevents this from being invoked.
         *
         * @deprecated 16.3, use getSnapshotBeforeUpdate instead
         * @see https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#reading-dom-properties-before-an-update
         * @see https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#gradual-migration-path
         */

        //@@{ 只读_:Readonly }
        UNSAFE_componentWillUpdate?(nextProps: 只读_<P>, nextState: 只读_<S>, nextContext: 任意): 无值;
    }

    接口 Mixin<P, S> 扩展 ComponentLifecycle<P, S> {

        //@@{ 数组_:Array }
        mixins?: 数组_<Mixin<P, S>>;
        statics?: {
            [key: 文字]: 任意;
        };

        displayName?: 文字;
        propTypes?: ValidationMap<任意>;
        contextTypes?: ValidationMap<任意>;
        childContextTypes?: ValidationMap<任意>;

        getDefaultProps?(): P;
        getInitialState?(): S;
    }

    接口 ComponentSpec<P, S> 扩展 Mixin<P, S> {
        render(): ReactNode;

        [propertyName: 文字]: 任意;
    }

    函数 createRef<T>(): RefObject<T>;

    // will show `ForwardRef(${Component.displayName || Component.name})` in devtools by default,
    // but can be given its own specific name
    接口 ForwardRefExoticComponent<P> 扩展 NamedExoticComponent<P> {

        //@@{ 可选_:Partial }
        defaultProps?: 可选_<P>;
    }

    函数 forwardRef<T, P = {}>(Component: RefForwardingComponent<T, P>): ForwardRefExoticComponent<PropsWithoutRef<P> & RefAttributes<T>>;

    /** Ensures that the props do not include ref at all */
    类型 PropsWithoutRef<P> =
        // Just Pick would be sufficient for this, but I'm trying to avoid unnecessary mapping over union types
        // https://github.com/Microsoft/TypeScript/issues/28339
        'ref' 扩展 键为 P

            //@@{ 挑选_:Pick, 排除_:Exclude }
            ? 挑选_<P, 排除_<键为 P, 'ref'>>
            : P;
    /** Ensures that the props do not include string ref, which cannot be forwarded */
    类型 PropsWithRef<P> =
        // Just "P extends { ref?: infer R }" looks sufficient, but R will infer as {} if P is {}.
        'ref' 扩展 键为 P
            ? P 扩展 { ref?: 推断 R }
                ? 文字 扩展 R

                    //@@{ 排除_:Exclude }
                    ? PropsWithoutRef<P> & { ref?: 排除_<R, 文字> }
                    : P
                : P
            : P;

    //@@{ 子属性:children }
    类型 PropsWithChildren<P> = P & { 子属性?: ReactNode };

    /**
     * NOTE: prefer ComponentPropsWithRef, if the ref is forwarded,
     * or ComponentPropsWithoutRef when refs are not supported.
     */

    //@@{ 内置元素_:IntrinsicElements }
    类型 ComponentProps<T 扩展 键为 JSX.内置元素_ | JSXElementConstructor<任意>> =
        T 扩展 JSXElementConstructor<推断 P>
            ? P

            //@@{ 内置元素_:IntrinsicElements }
            : T 扩展 键为 JSX.内置元素_

                //@@{ 内置元素_:IntrinsicElements }
                ? JSX.内置元素_[T]
                : {};
    类型 ComponentPropsWithRef<T 扩展 ElementType> =
        T 扩展 ComponentClass<推断 P>

            //@@{ 实例类型_:InstanceType }
            ? PropsWithoutRef<P> & RefAttributes<实例类型_<T>>
            : PropsWithRef<ComponentProps<T>>;
    类型 ComponentPropsWithoutRef<T 扩展 ElementType> =
        PropsWithoutRef<ComponentProps<T>>;

    // will show `Memo(${Component.displayName || Component.name})` in devtools by default,
    // but can be given its own specific name
    接口 MemoExoticComponent<T 扩展 ComponentType<任意>> 扩展 NamedExoticComponent<ComponentPropsWithRef<T>> {

        //@@{ 类型:type }
        只读 类型: T;
    }

    函数 memo<P 扩展 对象>(
        Component: SFC<P>,

        //@@{ 只读_:Readonly }
        propsAreEqual?: (prevProps: 只读_<PropsWithChildren<P>>, nextProps: 只读_<PropsWithChildren<P>>) => 真假
    ): NamedExoticComponent<P>;
    函数 memo<T 扩展 ComponentType<任意>>(
        Component: T,

        //@@{ 只读_:Readonly }
        propsAreEqual?: (prevProps: 只读_<ComponentProps<T>>, nextProps: 只读_<ComponentProps<T>>) => 真假
    ): MemoExoticComponent<T>;

    接口 LazyExoticComponent<T 扩展 ComponentType<任意>> 扩展 ExoticComponent<ComponentPropsWithRef<T>> {
        只读 _result: T;
    }

    函数 lazy<T 扩展 ComponentType<任意>>(

        //@@{ 预设_:Promise, 默认:default }
        工厂: () => 预设_<{ 默认: T }>
    ): LazyExoticComponent<T>;

    //
    // React Hooks
    // ----------------------------------------------------------------------

    // based on the code in https://github.com/facebook/react/pull/13968

    // Unlike the class component setState, the updates are not allowed to be partial
    类型 SetStateAction<S> = S | ((prevState: S) => S);
    // this technically does accept a second argument, but it's already under a deprecation warning
    // and it's not even released so probably better to not define it.
    类型 Dispatch<A> = (值: A) => 无值;
    // Unlike redux, the actions _can_ be anything
    类型 Reducer<S, A> = (prevState: S, action: A) => S;
    // types used to try and prevent the compiler from reducing S
    // to a supertype common with the second argument to useReducer()
    类型 ReducerState<R 扩展 Reducer<任意, 任意>> = R 扩展 Reducer<推断 S, 任意> ? S : 不及;
    类型 ReducerAction<R 扩展 Reducer<任意, 任意>> = R 扩展 Reducer<任意, 推断 A> ? A : 不及;
    // The identity check is done with the SameValue algorithm (Object.is), which is stricter than ===
    // TODO (TypeScript 3.0): ReadonlyArray<unknown>

    //@@{ 只读数组_:ReadonlyArray }
    类型 DependencyList = 只读数组_<任意>;

    // NOTE: callbacks are _only_ allowed to return either void, or a destructor.
    // The destructor is itself only allowed to return void.
    类型 EffectCallback = () => (无值 | (() => 无值 | 未定));

    接口 MutableRefObject<T> {
        current: T;
    }

    // This will technically work if you give a Consumer<T> or Provider<T> but it's deprecated and warns
    /**
     * Accepts a context object (the value returned from `React.createContext`) and returns the current
     * context value, as given by the nearest context provider for the given context.
     *
     * @version 16.8.0
     * @see https://reactjs.org/docs/hooks-reference.html#usecontext
     */
    函数 useContext<T>(context: Context<T>/*, (not public API) observedBits?: number|boolean */): T;
    /**
     * Returns a stateful value, and a function to update it.
     *
     * @version 16.8.0
     * @see https://reactjs.org/docs/hooks-reference.html#usestate
     */
    函数 useState<S>(initialState: S | (() => S)): [S, Dispatch<SetStateAction<S>>];
    // convenience overload when first argument is ommitted
    /**
     * Returns a stateful value, and a function to update it.
     *
     * @version 16.8.0
     * @see https://reactjs.org/docs/hooks-reference.html#usestate
     */
    函数 useState<S = 未定>(): [S | 未定, Dispatch<SetStateAction<S | 未定>>];
    /**
     * An alternative to `useState`.
     *
     * `useReducer` is usually preferable to `useState` when you have complex state logic that involves
     * multiple sub-values. It also lets you optimize performance for components that trigger deep
     * updates because you can pass `dispatch` down instead of callbacks.
     *
     * @version 16.8.0
     * @see https://reactjs.org/docs/hooks-reference.html#usereducer
     */
    // overload where "I" may be a subset of ReducerState<R>; used to provide autocompletion.
    // If "I" matches ReducerState<R> exactly then the last overload will allow initializer to be ommitted.
    // the last overload effectively behaves as if the identity function (x => x) is the initializer.
    函数 useReducer<R 扩展 Reducer<任意, 任意>, I>(
        reducer: R,
        initializerArg: I & ReducerState<R>,
        initializer: (实参: I & ReducerState<R>) => ReducerState<R>
    ): [ReducerState<R>, Dispatch<ReducerAction<R>>];
    /**
     * An alternative to `useState`.
     *
     * `useReducer` is usually preferable to `useState` when you have complex state logic that involves
     * multiple sub-values. It also lets you optimize performance for components that trigger deep
     * updates because you can pass `dispatch` down instead of callbacks.
     *
     * @version 16.8.0
     * @see https://reactjs.org/docs/hooks-reference.html#usereducer
     */
    // overload for free "I"; all goes as long as initializer converts it into "ReducerState<R>".
    函数 useReducer<R 扩展 Reducer<任意, 任意>, I>(
        reducer: R,
        initializerArg: I,
        initializer: (实参: I) => ReducerState<R>
    ): [ReducerState<R>, Dispatch<ReducerAction<R>>];
    /**
     * An alternative to `useState`.
     *
     * `useReducer` is usually preferable to `useState` when you have complex state logic that involves
     * multiple sub-values. It also lets you optimize performance for components that trigger deep
     * updates because you can pass `dispatch` down instead of callbacks.
     *
     * @version 16.8.0
     * @see https://reactjs.org/docs/hooks-reference.html#usereducer
     */

    // I'm not sure if I keep this 2-ary or if I make it (2,3)-ary; it's currently (2,3)-ary.
    // The Flow types do have an overload for 3-ary invocation with undefined initializer.

    // NOTE: without the ReducerState indirection, TypeScript would reduce S to be the most common
    // supertype between the reducer's return type and the initialState (or the initializer's return type),
    // which would prevent autocompletion from ever working.

    // TODO: double-check if this weird overload logic is necessary. It is possible it's either a bug
    // in older versions, or a regression in newer versions of the typescript completion service.
    函数 useReducer<R 扩展 Reducer<任意, 任意>>(
        reducer: R,
        initialState: ReducerState<R>,
        initializer?: 未定
    ): [ReducerState<R>, Dispatch<ReducerAction<R>>];
    /**
     * `useRef` returns a mutable ref object whose `.current` property is initialized to the passed argument
     * (`initialValue`). The returned object will persist for the full lifetime of the component.
     *
     * Note that `useRef()` is useful for more than the `ref` attribute. It’s handy for keeping any mutable
     * value around similar to how you’d use instance fields in classes.
     *
     * @version 16.8.0
     * @see https://reactjs.org/docs/hooks-reference.html#useref
     */
    // TODO (TypeScript 3.0): <T extends unknown>
    函数 useRef<T>(initialValue: T): MutableRefObject<T>;
    // convenience overload for refs given as a ref prop as they typically start with a null value
    /**
     * `useRef` returns a mutable ref object whose `.current` property is initialized to the passed argument
     * (`initialValue`). The returned object will persist for the full lifetime of the component.
     *
     * Note that `useRef()` is useful for more than the `ref` attribute. It’s handy for keeping any mutable
     * value around similar to how you’d use instance fields in classes.
     *
     * Usage note: if you need the result of useRef to be directly mutable, include `| null` in the type
     * of the generic argument.
     *
     * @version 16.8.0
     * @see https://reactjs.org/docs/hooks-reference.html#useref
     */
    // TODO (TypeScript 3.0): <T extends unknown>
    函数 useRef<T>(initialValue: T|空值): RefObject<T>;
    // convenience overload for potentially undefined initialValue / call with 0 arguments
    // has a default to stop it from defaulting to {} instead
    /**
     * `useRef` returns a mutable ref object whose `.current` property is initialized to the passed argument
     * (`initialValue`). The returned object will persist for the full lifetime of the component.
     *
     * Note that `useRef()` is useful for more than the `ref` attribute. It’s handy for keeping any mutable
     * value around similar to how you’d use instance fields in classes.
     *
     * @version 16.8.0
     * @see https://reactjs.org/docs/hooks-reference.html#useref
     */
    // TODO (TypeScript 3.0): <T extends unknown>
    函数 useRef<T = 未定>(): MutableRefObject<T | 未定>;
    /**
     * The signature is identical to `useEffect`, but it fires synchronously after all DOM mutations.
     * Use this to read layout from the DOM and synchronously re-render. Updates scheduled inside
     * `useLayoutEffect` will be flushed synchronously, before the browser has a chance to paint.
     *
     * Prefer the standard `useEffect` when possible to avoid blocking visual updates.
     *
     * If you’re migrating code from a class component, `useLayoutEffect` fires in the same phase as
     * `componentDidMount` and `componentDidUpdate`.
     *
     * @version 16.8.0
     * @see https://reactjs.org/docs/hooks-reference.html#uselayouteffect
     */
    函数 useLayoutEffect(effect: EffectCallback, deps?: DependencyList): 无值;
    /**
     * Accepts a function that contains imperative, possibly effectful code.
     *
     * @param effect Imperative function that can return a cleanup function
     * @param deps If present, effect will only activate if the values in the list change.
     *
     * @version 16.8.0
     * @see https://reactjs.org/docs/hooks-reference.html#useeffect
     */
    函数 useEffect(effect: EffectCallback, deps?: DependencyList): 无值;
    // NOTE: this does not accept strings, but this will have to be fixed by removing strings from type Ref<T>
    /**
     * `useImperativeHandle` customizes the instance value that is exposed to parent components when using
     * `ref`. As always, imperative code using refs should be avoided in most cases.
     *
     * `useImperativeHandle` should be used with `React.forwardRef`.
     *
     * @version 16.8.0
     * @see https://reactjs.org/docs/hooks-reference.html#useimperativehandle
     */
    函数 useImperativeHandle<T, R 扩展 T>(ref: Ref<T>|未定, init: () => R, deps?: DependencyList): 无值;
    // I made 'inputs' required here and in useMemo as there's no point to memoizing without the memoization key
    // useCallback(X) is identical to just using X, useMemo(() => Y) is identical to just using Y.
    /**
     * `useCallback` will return a memoized version of the callback that only changes if one of the `inputs`
     * has changed.
     *
     * @version 16.8.0
     * @see https://reactjs.org/docs/hooks-reference.html#usecallback
     */
    // TODO (TypeScript 3.0): <T extends (...args: never[]) => unknown>
    函数 useCallback<T 扩展 (...参数组: 任意[]) => 任意>(callback: T, deps: DependencyList): T;
    /**
     * `useMemo` will only recompute the memoized value when one of the `deps` has changed.
     *
     * Usage note: if calling `useMemo` with a referentially stable function, also give it as the input in
     * the second argument.
     *
     * ```ts
     * function expensive () { ... }
     *
     * function Component () {
     *   const expensiveResult = useMemo(expensive, [expensive])
     *   return ...
     * }
     * ```
     *
     * @version 16.8.0
     * @see https://reactjs.org/docs/hooks-reference.html#usememo
     */
    // allow undefined, but don't make it optional as that is very likely a mistake
    函数 useMemo<T>(工厂: () => T, deps: DependencyList | 未定): T;
    /**
     * `useDebugValue` can be used to display a label for custom hooks in React DevTools.
     *
     * NOTE: We don’t recommend adding debug values to every custom hook.
     * It’s most valuable for custom hooks that are part of shared libraries.
     *
     * @version 16.8.0
     * @see https://reactjs.org/docs/hooks-reference.html#usedebugvalue
     */
    // the name of the custom hook is itself derived from the function name at runtime:
    // it's just the function name without the "use" prefix.
    函数 useDebugValue<T>(值: T, format?: (值: T) => 任意): 无值;

    //
    // Event System
    // ----------------------------------------------------------------------
    // TODO: change any to unknown when moving to TS v3
    接口 BaseSyntheticEvent<E = 对象, C = 任意, T = 任意> {
        nativeEvent: E;
        currentTarget: C;

        //@@{ 目标:target }
        目标: T;
        bubbles: 真假;
        cancelable: 真假;
        defaultPrevented: 真假;
        eventPhase: 数字;
        isTrusted: 真假;
        preventDefault(): 无值;
        isDefaultPrevented(): 真假;
        stopPropagation(): 无值;
        isPropagationStopped(): 真假;
        persist(): 无值;
        timeStamp: 数字;

        //@@{ 类型:type }
        类型: 文字;
    }

    /**
     * currentTarget - a reference to the element on which the event listener is registered.
     *
     * target - a reference to the element from which the event was originally dispatched.
     * This might be a child element to the element on which the event listener is registered.
     * If you thought this should be `EventTarget & T`, see https://github.com/DefinitelyTyped/DefinitelyTyped/pull/12239
     */

    //@@{ 元素_:Element, 事件_:Event, 事件目标_:EventTarget }
    接口 SyntheticEvent<T = 元素_, E = 事件_> 扩展 BaseSyntheticEvent<E, 事件目标_ & T, 事件目标_> {}

    //@@{ 剪贴板事件_:ClipboardEvent, 元素_:Element }
    接口 剪贴板事件_<T = 元素_> 扩展 SyntheticEvent<T, NativeClipboardEvent> {

        //@@{ 数据传输_:DataTransfer }
        clipboardData: 数据传输_;
    }

    //@@{ 组件事件_:CompositionEvent, 元素_:Element }
    接口 组件事件_<T = 元素_> 扩展 SyntheticEvent<T, NativeCompositionEvent> {
        data: 文字;
    }

    //@@{ 拖拽事件_:DragEvent, 元素_:Element, 鼠标事件_:MouseEvent }
    接口 拖拽事件_<T = 元素_> 扩展 鼠标事件_<T, NativeDragEvent> {

        //@@{ 数据传输_:DataTransfer }
        dataTransfer: 数据传输_;
    }

    //@@{ 指针事件_:PointerEvent, 元素_:Element, 鼠标事件_:MouseEvent }
    接口 指针事件_<T = 元素_> 扩展 鼠标事件_<T, NativePointerEvent> {
        pointerId: 数字;
        pressure: 数字;
        tiltX: 数字;
        tiltY: 数字;
        width: 数字;
        height: 数字;
        pointerType: 'mouse' | 'pen' | 'touch';
        isPrimary: 真假;
    }

    //@@{ 焦点事件_:FocusEvent, 元素_:Element }
    接口 焦点事件_<T = 元素_> 扩展 SyntheticEvent<T, NativeFocusEvent> {

        //@@{ 事件目标_:EventTarget }
        relatedTarget: 事件目标_;

        //@@{ 目标:target, 事件目标_:EventTarget }
        目标: 事件目标_ & T;
    }

    // tslint:disable-next-line:no-empty-interface

    //@@{ 元素_:Element }
    接口 FormEvent<T = 元素_> 扩展 SyntheticEvent<T> {
    }

    //@@{ 元素_:Element }
    接口 InvalidEvent<T = 元素_> 扩展 SyntheticEvent<T> {

        //@@{ 目标:target, 事件目标_:EventTarget }
        目标: 事件目标_ & T;
    }

    //@@{ 元素_:Element }
    接口 ChangeEvent<T = 元素_> 扩展 SyntheticEvent<T> {

        //@@{ 目标:target, 事件目标_:EventTarget }
        目标: 事件目标_ & T;
    }

    //@@{ 键盘事件_:KeyboardEvent, 元素_:Element }
    接口 键盘事件_<T = 元素_> 扩展 SyntheticEvent<T, NativeKeyboardEvent> {
        altKey: 真假;
        charCode: 数字;
        ctrlKey: 真假;
        /**
         * See [DOM Level 3 Events spec](https://www.w3.org/TR/uievents-key/#keys-modifier). for a list of valid (case-sensitive) arguments to this method.
         */
        getModifierState(key: 文字): 真假;
        /**
         * See the [DOM Level 3 Events spec](https://www.w3.org/TR/uievents-key/#named-key-attribute-values). for possible values
         */
        key: 文字;
        keyCode: 数字;
        locale: 文字;
        location: 数字;
        metaKey: 真假;
        repeat: 真假;
        shiftKey: 真假;
        which: 数字;
    }

    //@@{ 鼠标事件_:MouseEvent, 元素_:Element }
    接口 鼠标事件_<T = 元素_, E = NativeMouseEvent> 扩展 SyntheticEvent<T, E> {
        altKey: 真假;
        button: 数字;
        buttons: 数字;
        clientX: 数字;
        clientY: 数字;
        ctrlKey: 真假;
        /**
         * See [DOM Level 3 Events spec](https://www.w3.org/TR/uievents-key/#keys-modifier). for a list of valid (case-sensitive) arguments to this method.
         */
        getModifierState(key: 文字): 真假;
        metaKey: 真假;
        movementX: 数字;
        movementY: 数字;
        pageX: 数字;
        pageY: 数字;

        //@@{ 事件目标_:EventTarget }
        relatedTarget: 事件目标_;
        screenX: 数字;
        screenY: 数字;
        shiftKey: 真假;
    }

    //@@{ 触摸事件_:TouchEvent, 元素_:Element }
    接口 触摸事件_<T = 元素_> 扩展 SyntheticEvent<T, NativeTouchEvent> {
        altKey: 真假;
        changedTouches: TouchList;
        ctrlKey: 真假;
        /**
         * See [DOM Level 3 Events spec](https://www.w3.org/TR/uievents-key/#keys-modifier). for a list of valid (case-sensitive) arguments to this method.
         */
        getModifierState(key: 文字): 真假;
        metaKey: 真假;
        shiftKey: 真假;
        targetTouches: TouchList;
        touches: TouchList;
    }

    //@@{ UI事件_:UIEvent, 元素_:Element }
    接口 UI事件_<T = 元素_> 扩展 SyntheticEvent<T, NativeUIEvent> {
        detail: 数字;
        view: AbstractView;
    }

    //@@{ 轮事件_:WheelEvent, 元素_:Element, 鼠标事件_:MouseEvent }
    接口 轮事件_<T = 元素_> 扩展 鼠标事件_<T, NativeWheelEvent> {
        deltaMode: 数字;
        deltaX: 数字;
        deltaY: 数字;
        deltaZ: 数字;
    }

    //@@{ 动画事件_:AnimationEvent, 元素_:Element }
    接口 动画事件_<T = 元素_> 扩展 SyntheticEvent<T, NativeAnimationEvent> {
        animationName: 文字;
        elapsedTime: 数字;
        pseudoElement: 文字;
    }

    //@@{ 过渡事件_:TransitionEvent, 元素_:Element }
    接口 过渡事件_<T = 元素_> 扩展 SyntheticEvent<T, NativeTransitionEvent> {
        elapsedTime: 数字;
        propertyName: 文字;
        pseudoElement: 文字;
    }

    //
    // Event Handler Types
    // ----------------------------------------------------------------------

    类型 EventHandler<E 扩展 SyntheticEvent<任意>> = { bivarianceHack(event: E): 无值 }["bivarianceHack"];

    //@@{ 元素_:Element }
    类型 ReactEventHandler<T = 元素_> = EventHandler<SyntheticEvent<T>>;

    //@@{ 元素_:Element, 剪贴板事件_:ClipboardEvent }
    类型 ClipboardEventHandler<T = 元素_> = EventHandler<剪贴板事件_<T>>;

    //@@{ 元素_:Element, 组件事件_:CompositionEvent }
    类型 CompositionEventHandler<T = 元素_> = EventHandler<组件事件_<T>>;

    //@@{ 元素_:Element, 拖拽事件_:DragEvent }
    类型 DragEventHandler<T = 元素_> = EventHandler<拖拽事件_<T>>;

    //@@{ 元素_:Element, 焦点事件_:FocusEvent }
    类型 FocusEventHandler<T = 元素_> = EventHandler<焦点事件_<T>>;

    //@@{ 元素_:Element }
    类型 FormEventHandler<T = 元素_> = EventHandler<FormEvent<T>>;

    //@@{ 元素_:Element }
    类型 ChangeEventHandler<T = 元素_> = EventHandler<ChangeEvent<T>>;

    //@@{ 元素_:Element, 键盘事件_:KeyboardEvent }
    类型 KeyboardEventHandler<T = 元素_> = EventHandler<键盘事件_<T>>;

    //@@{ 元素_:Element, 鼠标事件_:MouseEvent }
    类型 MouseEventHandler<T = 元素_> = EventHandler<鼠标事件_<T>>;

    //@@{ 元素_:Element, 触摸事件_:TouchEvent }
    类型 TouchEventHandler<T = 元素_> = EventHandler<触摸事件_<T>>;

    //@@{ 元素_:Element, 指针事件_:PointerEvent }
    类型 PointerEventHandler<T = 元素_> = EventHandler<指针事件_<T>>;

    //@@{ 元素_:Element, UI事件_:UIEvent }
    类型 UIEventHandler<T = 元素_> = EventHandler<UI事件_<T>>;

    //@@{ 元素_:Element, 轮事件_:WheelEvent }
    类型 WheelEventHandler<T = 元素_> = EventHandler<轮事件_<T>>;

    //@@{ 元素_:Element, 动画事件_:AnimationEvent }
    类型 AnimationEventHandler<T = 元素_> = EventHandler<动画事件_<T>>;

    //@@{ 元素_:Element, 过渡事件_:TransitionEvent }
    类型 TransitionEventHandler<T = 元素_> = EventHandler<过渡事件_<T>>;

    //
    // Props / DOM Attributes
    // ----------------------------------------------------------------------

    /**
     * @deprecated. This was used to allow clients to pass `ref` and `key`
     * to `createElement`, which is no longer necessary due to intersection
     * types. If you need to declare a props object before passing it to
     * `createElement` or a factory, use `ClassAttributes<T>`:
     *
     * ```ts
     * var b: Button | null;
     * var props: ButtonProps & ClassAttributes<Button> = {
     *     ref: b => button = b, // ok!
     *     label: "I'm a Button"
     * };
     * ```
     */
    接口 Props<T> {

        //@@{ 子属性:children }
        子属性?: ReactNode;
        key?: Key;
        ref?: LegacyRef<T>;
    }

    接口 HTMLProps<T> 扩展 AllHTMLAttributes<T>, ClassAttributes<T> {
    }

    类型 DetailedHTMLProps<E 扩展 HTMLAttributes<T>, T> = ClassAttributes<T> & E;

    接口 SVGProps<T> 扩展 SVGAttributes<T>, ClassAttributes<T> {
    }

    接口 DOMAttributes<T> {

        //@@{ 子属性:children }
        子属性?: ReactNode;
        dangerouslySetInnerHTML?: {
            __html: 文字;
        };

        // Clipboard Events
        onCopy?: ClipboardEventHandler<T>;
        onCopyCapture?: ClipboardEventHandler<T>;
        onCut?: ClipboardEventHandler<T>;
        onCutCapture?: ClipboardEventHandler<T>;
        onPaste?: ClipboardEventHandler<T>;
        onPasteCapture?: ClipboardEventHandler<T>;

        // Composition Events
        onCompositionEnd?: CompositionEventHandler<T>;
        onCompositionEndCapture?: CompositionEventHandler<T>;
        onCompositionStart?: CompositionEventHandler<T>;
        onCompositionStartCapture?: CompositionEventHandler<T>;
        onCompositionUpdate?: CompositionEventHandler<T>;
        onCompositionUpdateCapture?: CompositionEventHandler<T>;

        // Focus Events
        onFocus?: FocusEventHandler<T>;
        onFocusCapture?: FocusEventHandler<T>;
        onBlur?: FocusEventHandler<T>;
        onBlurCapture?: FocusEventHandler<T>;

        // Form Events
        onChange?: FormEventHandler<T>;
        onChangeCapture?: FormEventHandler<T>;
        onBeforeInput?: FormEventHandler<T>;
        onBeforeInputCapture?: FormEventHandler<T>;
        onInput?: FormEventHandler<T>;
        onInputCapture?: FormEventHandler<T>;
        onReset?: FormEventHandler<T>;
        onResetCapture?: FormEventHandler<T>;
        onSubmit?: FormEventHandler<T>;
        onSubmitCapture?: FormEventHandler<T>;
        onInvalid?: FormEventHandler<T>;
        onInvalidCapture?: FormEventHandler<T>;

        // Image Events
        onLoad?: ReactEventHandler<T>;
        onLoadCapture?: ReactEventHandler<T>;
        onError?: ReactEventHandler<T>; // also a Media Event
        onErrorCapture?: ReactEventHandler<T>; // also a Media Event

        // Keyboard Events
        onKeyDown?: KeyboardEventHandler<T>;
        onKeyDownCapture?: KeyboardEventHandler<T>;
        onKeyPress?: KeyboardEventHandler<T>;
        onKeyPressCapture?: KeyboardEventHandler<T>;
        onKeyUp?: KeyboardEventHandler<T>;
        onKeyUpCapture?: KeyboardEventHandler<T>;

        // Media Events
        onAbort?: ReactEventHandler<T>;
        onAbortCapture?: ReactEventHandler<T>;
        onCanPlay?: ReactEventHandler<T>;
        onCanPlayCapture?: ReactEventHandler<T>;
        onCanPlayThrough?: ReactEventHandler<T>;
        onCanPlayThroughCapture?: ReactEventHandler<T>;
        onDurationChange?: ReactEventHandler<T>;
        onDurationChangeCapture?: ReactEventHandler<T>;
        onEmptied?: ReactEventHandler<T>;
        onEmptiedCapture?: ReactEventHandler<T>;
        onEncrypted?: ReactEventHandler<T>;
        onEncryptedCapture?: ReactEventHandler<T>;
        onEnded?: ReactEventHandler<T>;
        onEndedCapture?: ReactEventHandler<T>;
        onLoadedData?: ReactEventHandler<T>;
        onLoadedDataCapture?: ReactEventHandler<T>;
        onLoadedMetadata?: ReactEventHandler<T>;
        onLoadedMetadataCapture?: ReactEventHandler<T>;
        onLoadStart?: ReactEventHandler<T>;
        onLoadStartCapture?: ReactEventHandler<T>;
        onPause?: ReactEventHandler<T>;
        onPauseCapture?: ReactEventHandler<T>;
        onPlay?: ReactEventHandler<T>;
        onPlayCapture?: ReactEventHandler<T>;
        onPlaying?: ReactEventHandler<T>;
        onPlayingCapture?: ReactEventHandler<T>;
        onProgress?: ReactEventHandler<T>;
        onProgressCapture?: ReactEventHandler<T>;
        onRateChange?: ReactEventHandler<T>;
        onRateChangeCapture?: ReactEventHandler<T>;
        onSeeked?: ReactEventHandler<T>;
        onSeekedCapture?: ReactEventHandler<T>;
        onSeeking?: ReactEventHandler<T>;
        onSeekingCapture?: ReactEventHandler<T>;
        onStalled?: ReactEventHandler<T>;
        onStalledCapture?: ReactEventHandler<T>;
        onSuspend?: ReactEventHandler<T>;
        onSuspendCapture?: ReactEventHandler<T>;
        onTimeUpdate?: ReactEventHandler<T>;
        onTimeUpdateCapture?: ReactEventHandler<T>;
        onVolumeChange?: ReactEventHandler<T>;
        onVolumeChangeCapture?: ReactEventHandler<T>;
        onWaiting?: ReactEventHandler<T>;
        onWaitingCapture?: ReactEventHandler<T>;

        // MouseEvents
        onAuxClick?: MouseEventHandler<T>;
        onAuxClickCapture?: MouseEventHandler<T>;
        onClick?: MouseEventHandler<T>;
        onClickCapture?: MouseEventHandler<T>;
        onContextMenu?: MouseEventHandler<T>;
        onContextMenuCapture?: MouseEventHandler<T>;
        onDoubleClick?: MouseEventHandler<T>;
        onDoubleClickCapture?: MouseEventHandler<T>;
        onDrag?: DragEventHandler<T>;
        onDragCapture?: DragEventHandler<T>;
        onDragEnd?: DragEventHandler<T>;
        onDragEndCapture?: DragEventHandler<T>;
        onDragEnter?: DragEventHandler<T>;
        onDragEnterCapture?: DragEventHandler<T>;
        onDragExit?: DragEventHandler<T>;
        onDragExitCapture?: DragEventHandler<T>;
        onDragLeave?: DragEventHandler<T>;
        onDragLeaveCapture?: DragEventHandler<T>;
        onDragOver?: DragEventHandler<T>;
        onDragOverCapture?: DragEventHandler<T>;
        onDragStart?: DragEventHandler<T>;
        onDragStartCapture?: DragEventHandler<T>;
        onDrop?: DragEventHandler<T>;
        onDropCapture?: DragEventHandler<T>;
        onMouseDown?: MouseEventHandler<T>;
        onMouseDownCapture?: MouseEventHandler<T>;
        onMouseEnter?: MouseEventHandler<T>;
        onMouseLeave?: MouseEventHandler<T>;
        onMouseMove?: MouseEventHandler<T>;
        onMouseMoveCapture?: MouseEventHandler<T>;
        onMouseOut?: MouseEventHandler<T>;
        onMouseOutCapture?: MouseEventHandler<T>;
        onMouseOver?: MouseEventHandler<T>;
        onMouseOverCapture?: MouseEventHandler<T>;
        onMouseUp?: MouseEventHandler<T>;
        onMouseUpCapture?: MouseEventHandler<T>;

        // Selection Events
        onSelect?: ReactEventHandler<T>;
        onSelectCapture?: ReactEventHandler<T>;

        // Touch Events
        onTouchCancel?: TouchEventHandler<T>;
        onTouchCancelCapture?: TouchEventHandler<T>;
        onTouchEnd?: TouchEventHandler<T>;
        onTouchEndCapture?: TouchEventHandler<T>;
        onTouchMove?: TouchEventHandler<T>;
        onTouchMoveCapture?: TouchEventHandler<T>;
        onTouchStart?: TouchEventHandler<T>;
        onTouchStartCapture?: TouchEventHandler<T>;

        // Pointer Events
        onPointerDown?: PointerEventHandler<T>;
        onPointerDownCapture?: PointerEventHandler<T>;
        onPointerMove?: PointerEventHandler<T>;
        onPointerMoveCapture?: PointerEventHandler<T>;
        onPointerUp?: PointerEventHandler<T>;
        onPointerUpCapture?: PointerEventHandler<T>;
        onPointerCancel?: PointerEventHandler<T>;
        onPointerCancelCapture?: PointerEventHandler<T>;
        onPointerEnter?: PointerEventHandler<T>;
        onPointerEnterCapture?: PointerEventHandler<T>;
        onPointerLeave?: PointerEventHandler<T>;
        onPointerLeaveCapture?: PointerEventHandler<T>;
        onPointerOver?: PointerEventHandler<T>;
        onPointerOverCapture?: PointerEventHandler<T>;
        onPointerOut?: PointerEventHandler<T>;
        onPointerOutCapture?: PointerEventHandler<T>;
        onGotPointerCapture?: PointerEventHandler<T>;
        onGotPointerCaptureCapture?: PointerEventHandler<T>;
        onLostPointerCapture?: PointerEventHandler<T>;
        onLostPointerCaptureCapture?: PointerEventHandler<T>;

        // UI Events
        onScroll?: UIEventHandler<T>;
        onScrollCapture?: UIEventHandler<T>;

        // Wheel Events
        onWheel?: WheelEventHandler<T>;
        onWheelCapture?: WheelEventHandler<T>;

        // Animation Events
        onAnimationStart?: AnimationEventHandler<T>;
        onAnimationStartCapture?: AnimationEventHandler<T>;
        onAnimationEnd?: AnimationEventHandler<T>;
        onAnimationEndCapture?: AnimationEventHandler<T>;
        onAnimationIteration?: AnimationEventHandler<T>;
        onAnimationIterationCapture?: AnimationEventHandler<T>;

        // Transition Events
        onTransitionEnd?: TransitionEventHandler<T>;
        onTransitionEndCapture?: TransitionEventHandler<T>;
    }

    导出 接口 CSSProperties 扩展 CSS.Properties<文字 | 数字> {
        /**
         * The index signature was removed to enable closed typing for style
         * using CSSType. You're able to use type assertion or module augmentation
         * to add properties or an index signature of your own.
         *
         * For examples and more information, visit:
         * https://github.com/frenic/csstype#what-should-i-do-when-i-get-type-errors
         */
    }

    // All the WAI-ARIA 1.1 attributes from https://www.w3.org/TR/wai-aria-1.1/
    接口 AriaAttributes {
        /** Identifies the currently active element when DOM focus is on a composite widget, textbox, group, or application. */
        'aria-activedescendant'?: 文字;
        /** Indicates whether assistive technologies will present all, or only parts of, the changed region based on the change notifications defined by the aria-relevant attribute. */

        //@@{ "为假":"false", "为真":"true" }
        'aria-atomic'?: 真假 | "为假" | "为真";
        /**
         * Indicates whether inputting text could trigger display of one or more predictions of the user's intended value for an input and specifies how predictions would be
         * presented if they are made.
         */
        'aria-autocomplete'?: 'none' | 'inline' | 'list' | 'both';
        /** Indicates an element is being modified and that assistive technologies MAY want to wait until the modifications are complete before exposing them to the user. */

        //@@{ "为假":"false", "为真":"true" }
        'aria-busy'?: 真假 | "为假" | "为真";
        /**
         * Indicates the current "checked" state of checkboxes, radio buttons, and other widgets.
         * @see aria-pressed @see aria-selected.
         */

        //@@{ "为假":"false", "为真":"true" }
        'aria-checked'?: 真假 | "为假" | 'mixed' | "为真";
        /**
         * Defines the total number of columns in a table, grid, or treegrid.
         * @see aria-colindex.
         */
        'aria-colcount'?: 数字;
        /**
         * Defines an element's column index or position with respect to the total number of columns within a table, grid, or treegrid.
         * @see aria-colcount @see aria-colspan.
         */
        'aria-colindex'?: 数字;
        /**
         * Defines the number of columns spanned by a cell or gridcell within a table, grid, or treegrid.
         * @see aria-colindex @see aria-rowspan.
         */
        'aria-colspan'?: 数字;
        /**
         * Identifies the element (or elements) whose contents or presence are controlled by the current element.
         * @see aria-owns.
         */
        'aria-controls'?: 文字;
        /** Indicates the element that represents the current item within a container or set of related elements. */

        //@@{ "为假":"false", "为真":"true" }
        'aria-current'?: 真假 | "为假" | "为真" | 'page' | 'step' | 'location' | 'date' | 'time';
        /**
         * Identifies the element (or elements) that describes the object.
         * @see aria-labelledby
         */
        'aria-describedby'?: 文字;
        /**
         * Identifies the element that provides a detailed, extended description for the object.
         * @see aria-describedby.
         */
        'aria-details'?: 文字;
        /**
         * Indicates that the element is perceivable but disabled, so it is not editable or otherwise operable.
         * @see aria-hidden @see aria-readonly.
         */

        //@@{ "为假":"false", "为真":"true" }
        'aria-disabled'?: 真假 | "为假" | "为真";
        /**
         * Indicates what functions can be performed when a dragged object is released on the drop target.
         * @deprecated in ARIA 1.1
         */

        //@@{ "链接":"link" }
        'aria-dropeffect'?: 'none' | 'copy' | 'execute' | "链接" | 'move' | 'popup';
        /**
         * Identifies the element that provides an error message for the object.
         * @see aria-invalid @see aria-describedby.
         */
        'aria-errormessage'?: 文字;
        /** Indicates whether the element, or another grouping element it controls, is currently expanded or collapsed. */

        //@@{ "为假":"false", "为真":"true" }
        'aria-expanded'?: 真假 | "为假" | "为真";
        /**
         * Identifies the next element (or elements) in an alternate reading order of content which, at the user's discretion,
         * allows assistive technology to override the general default of reading in document source order.
         */
        'aria-flowto'?: 文字;
        /**
         * Indicates an element's "grabbed" state in a drag-and-drop operation.
         * @deprecated in ARIA 1.1
         */

        //@@{ "为假":"false", "为真":"true" }
        'aria-grabbed'?: 真假 | "为假" | "为真";
        /** Indicates the availability and type of interactive popup element, such as menu or dialog, that can be triggered by an element. */

        //@@{ "为假":"false", "为真":"true" }
        'aria-haspopup'?: 真假 | "为假" | "为真" | 'menu' | 'listbox' | 'tree' | 'grid' | 'dialog';
        /**
         * Indicates whether the element is exposed to an accessibility API.
         * @see aria-disabled.
         */

        //@@{ "为假":"false", "为真":"true" }
        'aria-hidden'?: 真假 | "为假" | "为真";
        /**
         * Indicates the entered value does not conform to the format expected by the application.
         * @see aria-errormessage.
         */

        //@@{ "为假":"false", "为真":"true" }
        'aria-invalid'?: 真假 | "为假" | "为真" | 'grammar' | 'spelling';
        /** Indicates keyboard shortcuts that an author has implemented to activate or give focus to an element. */
        'aria-keyshortcuts'?: 文字;
        /**
         * Defines a string value that labels the current element.
         * @see aria-labelledby.
         */
        'aria-label'?: 文字;
        /**
         * Identifies the element (or elements) that labels the current element.
         * @see aria-describedby.
         */
        'aria-labelledby'?: 文字;
        /** Defines the hierarchical level of an element within a structure. */
        'aria-level'?: 数字;
        /** Indicates that an element will be updated, and describes the types of updates the user agents, assistive technologies, and user can expect from the live region. */
        'aria-live'?: 'off' | 'assertive' | 'polite';
        /** Indicates whether an element is modal when displayed. */

        //@@{ "为假":"false", "为真":"true" }
        'aria-modal'?: 真假 | "为假" | "为真";
        /** Indicates whether a text box accepts multiple lines of input or only a single line. */

        //@@{ "为假":"false", "为真":"true" }
        'aria-multiline'?: 真假 | "为假" | "为真";
        /** Indicates that the user may select more than one item from the current selectable descendants. */

        //@@{ "为假":"false", "为真":"true" }
        'aria-multiselectable'?: 真假 | "为假" | "为真";
        /** Indicates whether the element's orientation is horizontal, vertical, or unknown/ambiguous. */
        'aria-orientation'?: 'horizontal' | 'vertical';
        /**
         * Identifies an element (or elements) in order to define a visual, functional, or contextual parent/child relationship
         * between DOM elements where the DOM hierarchy cannot be used to represent the relationship.
         * @see aria-controls.
         */
        'aria-owns'?: 文字;
        /**
         * Defines a short hint (a word or short phrase) intended to aid the user with data entry when the control has no value.
         * A hint could be a sample value or a brief description of the expected format.
         */
        'aria-placeholder'?: 文字;
        /**
         * Defines an element's number or position in the current set of listitems or treeitems. Not required if all elements in the set are present in the DOM.
         * @see aria-setsize.
         */
        'aria-posinset'?: 数字;
        /**
         * Indicates the current "pressed" state of toggle buttons.
         * @see aria-checked @see aria-selected.
         */

        //@@{ "为假":"false", "为真":"true" }
        'aria-pressed'?: 真假 | "为假" | 'mixed' | "为真";
        /**
         * Indicates that the element is not editable, but is otherwise operable.
         * @see aria-disabled.
         */

        //@@{ "为假":"false", "为真":"true" }
        'aria-readonly'?: 真假 | "为假" | "为真";
        /**
         * Indicates what notifications the user agent will trigger when the accessibility tree within a live region is modified.
         * @see aria-atomic.
         */
        'aria-relevant'?: 'additions' | 'additions text' | 'all' | 'removals' | 'text';
        /** Indicates that user input is required on the element before a form may be submitted. */

        //@@{ "为假":"false", "为真":"true" }
        'aria-required'?: 真假 | "为假" | "为真";
        /** Defines a human-readable, author-localized description for the role of an element. */
        'aria-roledescription'?: 文字;
        /**
         * Defines the total number of rows in a table, grid, or treegrid.
         * @see aria-rowindex.
         */
        'aria-rowcount'?: 数字;
        /**
         * Defines an element's row index or position with respect to the total number of rows within a table, grid, or treegrid.
         * @see aria-rowcount @see aria-rowspan.
         */
        'aria-rowindex'?: 数字;
        /**
         * Defines the number of rows spanned by a cell or gridcell within a table, grid, or treegrid.
         * @see aria-rowindex @see aria-colspan.
         */
        'aria-rowspan'?: 数字;
        /**
         * Indicates the current "selected" state of various widgets.
         * @see aria-checked @see aria-pressed.
         */

        //@@{ "为假":"false", "为真":"true" }
        'aria-selected'?: 真假 | "为假" | "为真";
        /**
         * Defines the number of items in the current set of listitems or treeitems. Not required if all elements in the set are present in the DOM.
         * @see aria-posinset.
         */
        'aria-setsize'?: 数字;
        /** Indicates if items in a table or grid are sorted in ascending or descending order. */
        'aria-sort'?: 'none' | 'ascending' | 'descending' | 'other';
        /** Defines the maximum allowed value for a range widget. */
        'aria-valuemax'?: 数字;
        /** Defines the minimum allowed value for a range widget. */
        'aria-valuemin'?: 数字;
        /**
         * Defines the current value for a range widget.
         * @see aria-valuetext.
         */
        'aria-valuenow'?: 数字;
        /** Defines the human readable text alternative of aria-valuenow for a range widget. */
        'aria-valuetext'?: 文字;
    }

    接口 HTMLAttributes<T> 扩展 AriaAttributes, DOMAttributes<T> {
        // React-specific Attributes
        defaultChecked?: 真假;
        defaultValue?: 文字 | 文字[];
        suppressContentEditableWarning?: 真假;
        suppressHydrationWarning?: 真假;

        // Standard HTML Attributes
        accessKey?: 文字;
        className?: 文字;
        contentEditable?: 真假;
        contextMenu?: 文字;
        dir?: 文字;
        draggable?: 真假;
        hidden?: 真假;
        id?: 文字;
        lang?: 文字;
        placeholder?: 文字;
        slot?: 文字;
        spellCheck?: 真假;
        style?: CSSProperties;
        tabIndex?: 数字;
        title?: 文字;

        // Unknown
        inputMode?: 文字;

        //@@{ 作为:is }
        作为?: 文字;
        radioGroup?: 文字; // <command>, <menuitem>

        // WAI-ARIA
        role?: 文字;

        // RDFa Attributes
        about?: 文字;
        datatype?: 文字;
        inlist?: 任意;
        prefix?: 文字;

        //@@{ 特性:property }
        特性?: 文字;
        resource?: 文字;

        //@@{ 类为:typeof }
        类为?: 文字;
        vocab?: 文字;

        // Non-standard Attributes
        autoCapitalize?: 文字;
        autoCorrect?: 文字;
        autoSave?: 文字;
        color?: 文字;
        itemProp?: 文字;
        itemScope?: 真假;
        itemType?: 文字;
        itemID?: 文字;
        itemRef?: 文字;
        results?: 数字;
        security?: 文字;
        unselectable?: 'on' | 'off';
    }

    接口 AllHTMLAttributes<T> 扩展 HTMLAttributes<T> {
        // Standard HTML Attributes
        accept?: 文字;
        acceptCharset?: 文字;
        action?: 文字;
        allowFullScreen?: 真假;
        allowTransparency?: 真假;
        alt?: 文字;

        //@@{ 转为:as }
        转为?: 文字;

        //@@{ 异步:async }
        异步?: 真假;
        autoComplete?: 文字;
        autoFocus?: 真假;
        autoPlay?: 真假;
        capture?: 真假 | 文字;
        cellPadding?: 数字 | 文字;
        cellSpacing?: 数字 | 文字;
        charSet?: 文字;
        challenge?: 文字;
        checked?: 真假;
        cite?: 文字;
        classID?: 文字;
        cols?: 数字;
        colSpan?: 数字;
        content?: 文字;
        controls?: 真假;
        coords?: 文字;
        crossOrigin?: 文字;
        data?: 文字;
        dateTime?: 文字;

        //@@{ 默认:default }
        默认?: 真假;
        defer?: 真假;
        disabled?: 真假;
        download?: 任意;
        encType?: 文字;
        form?: 文字;
        formAction?: 文字;
        formEncType?: 文字;
        formMethod?: 文字;
        formNoValidate?: 真假;
        formTarget?: 文字;
        frameBorder?: 数字 | 文字;
        headers?: 文字;
        height?: 数字 | 文字;
        high?: 数字;
        href?: 文字;
        hrefLang?: 文字;
        htmlFor?: 文字;
        httpEquiv?: 文字;
        integrity?: 文字;
        keyParams?: 文字;
        keyType?: 文字;
        kind?: 文字;
        label?: 文字;
        list?: 文字;
        loop?: 真假;
        low?: 数字;
        manifest?: 文字;
        marginHeight?: 数字;
        marginWidth?: 数字;
        max?: 数字 | 文字;
        maxLength?: 数字;
        media?: 文字;
        mediaGroup?: 文字;
        method?: 文字;
        min?: 数字 | 文字;
        minLength?: 数字;
        multiple?: 真假;
        muted?: 真假;

        //@@{ 名称:name }
        名称?: 文字;
        nonce?: 文字;
        noValidate?: 真假;
        open?: 真假;
        optimum?: 数字;
        pattern?: 文字;
        placeholder?: 文字;
        playsInline?: 真假;
        poster?: 文字;
        preload?: 文字;
        readOnly?: 真假;
        rel?: 文字;
        required?: 真假;
        reversed?: 真假;
        rows?: 数字;
        rowSpan?: 数字;
        sandbox?: 文字;
        scope?: 文字;
        scoped?: 真假;
        scrolling?: 文字;
        seamless?: 真假;
        selected?: 真假;
        shape?: 文字;
        size?: 数字;
        sizes?: 文字;
        span?: 数字;
        src?: 文字;
        srcDoc?: 文字;
        srcLang?: 文字;
        srcSet?: 文字;
        start?: 数字;
        step?: 数字 | 文字;
        summary?: 文字;

        //@@{ 目标:target }
        目标?: 文字;

        //@@{ 类型:type }
        类型?: 文字;
        useMap?: 文字;

        //@@{ 值:value }
        值?: 文字 | 文字[] | 数字;
        width?: 数字 | 文字;
        wmode?: 文字;
        wrap?: 文字;
    }

    接口 AnchorHTMLAttributes<T> 扩展 HTMLAttributes<T> {
        download?: 任意;
        href?: 文字;
        hrefLang?: 文字;
        media?: 文字;
        rel?: 文字;

        //@@{ 目标:target }
        目标?: 文字;

        //@@{ 类型:type }
        类型?: 文字;
        referrerPolicy?: 文字;
    }

    // tslint:disable-next-line:no-empty-interface
    接口 AudioHTMLAttributes<T> 扩展 MediaHTMLAttributes<T> {}

    接口 AreaHTMLAttributes<T> 扩展 HTMLAttributes<T> {
        alt?: 文字;
        coords?: 文字;
        download?: 任意;
        href?: 文字;
        hrefLang?: 文字;
        media?: 文字;
        rel?: 文字;
        shape?: 文字;

        //@@{ 目标:target }
        目标?: 文字;
    }

    接口 BaseHTMLAttributes<T> 扩展 HTMLAttributes<T> {
        href?: 文字;

        //@@{ 目标:target }
        目标?: 文字;
    }

    接口 BlockquoteHTMLAttributes<T> 扩展 HTMLAttributes<T> {
        cite?: 文字;
    }

    接口 ButtonHTMLAttributes<T> 扩展 HTMLAttributes<T> {
        autoFocus?: 真假;
        disabled?: 真假;
        form?: 文字;
        formAction?: 文字;
        formEncType?: 文字;
        formMethod?: 文字;
        formNoValidate?: 真假;
        formTarget?: 文字;

        //@@{ 名称:name }
        名称?: 文字;

        //@@{ 类型:type }
        类型?: 'submit' | 'reset' | 'button';

        //@@{ 值:value }
        值?: 文字 | 文字[] | 数字;
    }

    接口 CanvasHTMLAttributes<T> 扩展 HTMLAttributes<T> {
        height?: 数字 | 文字;
        width?: 数字 | 文字;
    }

    接口 ColHTMLAttributes<T> 扩展 HTMLAttributes<T> {
        span?: 数字;
        width?: 数字 | 文字;
    }

    接口 ColgroupHTMLAttributes<T> 扩展 HTMLAttributes<T> {
        span?: 数字;
    }

    接口 DetailsHTMLAttributes<T> 扩展 HTMLAttributes<T> {
        open?: 真假;
    }

    接口 DelHTMLAttributes<T> 扩展 HTMLAttributes<T> {
        cite?: 文字;
        dateTime?: 文字;
    }

    接口 DialogHTMLAttributes<T> 扩展 HTMLAttributes<T> {
        open?: 真假;
    }

    接口 EmbedHTMLAttributes<T> 扩展 HTMLAttributes<T> {
        height?: 数字 | 文字;
        src?: 文字;

        //@@{ 类型:type }
        类型?: 文字;
        width?: 数字 | 文字;
    }

    接口 FieldsetHTMLAttributes<T> 扩展 HTMLAttributes<T> {
        disabled?: 真假;
        form?: 文字;

        //@@{ 名称:name }
        名称?: 文字;
    }

    接口 FormHTMLAttributes<T> 扩展 HTMLAttributes<T> {
        acceptCharset?: 文字;
        action?: 文字;
        autoComplete?: 文字;
        encType?: 文字;
        method?: 文字;

        //@@{ 名称:name }
        名称?: 文字;
        noValidate?: 真假;

        //@@{ 目标:target }
        目标?: 文字;
    }

    接口 HtmlHTMLAttributes<T> 扩展 HTMLAttributes<T> {
        manifest?: 文字;
    }

    接口 IframeHTMLAttributes<T> 扩展 HTMLAttributes<T> {
        allow?: 文字;
        allowFullScreen?: 真假;
        allowTransparency?: 真假;
        frameBorder?: 数字 | 文字;
        height?: 数字 | 文字;
        marginHeight?: 数字;
        marginWidth?: 数字;

        //@@{ 名称:name }
        名称?: 文字;
        sandbox?: 文字;
        scrolling?: 文字;
        seamless?: 真假;
        src?: 文字;
        srcDoc?: 文字;
        width?: 数字 | 文字;
    }

    接口 ImgHTMLAttributes<T> 扩展 HTMLAttributes<T> {
        alt?: 文字;
        crossOrigin?: "anonymous" | "use-credentials" | "";

        //@@{ "异步":"async" }
        decoding?: "异步" | "auto" | "sync";
        height?: 数字 | 文字;
        sizes?: 文字;
        src?: 文字;
        srcSet?: 文字;
        useMap?: 文字;
        width?: 数字 | 文字;
    }

    接口 InsHTMLAttributes<T> 扩展 HTMLAttributes<T> {
        cite?: 文字;
        dateTime?: 文字;
    }

    接口 InputHTMLAttributes<T> 扩展 HTMLAttributes<T> {
        accept?: 文字;
        alt?: 文字;
        autoComplete?: 文字;
        autoFocus?: 真假;
        capture?: 真假 | 文字; // https://www.w3.org/TR/html-media-capture/#the-capture-attribute
        checked?: 真假;
        crossOrigin?: 文字;
        disabled?: 真假;
        form?: 文字;
        formAction?: 文字;
        formEncType?: 文字;
        formMethod?: 文字;
        formNoValidate?: 真假;
        formTarget?: 文字;
        height?: 数字 | 文字;
        list?: 文字;
        max?: 数字 | 文字;
        maxLength?: 数字;
        min?: 数字 | 文字;
        minLength?: 数字;
        multiple?: 真假;

        //@@{ 名称:name }
        名称?: 文字;
        pattern?: 文字;
        placeholder?: 文字;
        readOnly?: 真假;
        required?: 真假;
        size?: 数字;
        src?: 文字;
        step?: 数字 | 文字;

        //@@{ 类型:type }
        类型?: 文字;

        //@@{ 值:value }
        值?: 文字 | 文字[] | 数字;
        width?: 数字 | 文字;

        onChange?: ChangeEventHandler<T>;
    }

    接口 KeygenHTMLAttributes<T> 扩展 HTMLAttributes<T> {
        autoFocus?: 真假;
        challenge?: 文字;
        disabled?: 真假;
        form?: 文字;
        keyType?: 文字;
        keyParams?: 文字;

        //@@{ 名称:name }
        名称?: 文字;
    }

    接口 LabelHTMLAttributes<T> 扩展 HTMLAttributes<T> {
        form?: 文字;
        htmlFor?: 文字;
    }

    接口 LiHTMLAttributes<T> 扩展 HTMLAttributes<T> {

        //@@{ 值:value }
        值?: 文字 | 文字[] | 数字;
    }

    接口 LinkHTMLAttributes<T> 扩展 HTMLAttributes<T> {

        //@@{ 转为:as }
        转为?: 文字;
        crossOrigin?: 文字;
        href?: 文字;
        hrefLang?: 文字;
        integrity?: 文字;
        media?: 文字;
        rel?: 文字;
        sizes?: 文字;

        //@@{ 类型:type }
        类型?: 文字;
    }

    接口 MapHTMLAttributes<T> 扩展 HTMLAttributes<T> {

        //@@{ 名称:name }
        名称?: 文字;
    }

    接口 MenuHTMLAttributes<T> 扩展 HTMLAttributes<T> {

        //@@{ 类型:type }
        类型?: 文字;
    }

    接口 MediaHTMLAttributes<T> 扩展 HTMLAttributes<T> {
        autoPlay?: 真假;
        controls?: 真假;
        controlsList?: 文字;
        crossOrigin?: 文字;
        loop?: 真假;
        mediaGroup?: 文字;
        muted?: 真假;
        playsinline?: 真假;
        preload?: 文字;
        src?: 文字;
    }

    接口 MetaHTMLAttributes<T> 扩展 HTMLAttributes<T> {
        charSet?: 文字;
        content?: 文字;
        httpEquiv?: 文字;

        //@@{ 名称:name }
        名称?: 文字;
    }

    接口 MeterHTMLAttributes<T> 扩展 HTMLAttributes<T> {
        form?: 文字;
        high?: 数字;
        low?: 数字;
        max?: 数字 | 文字;
        min?: 数字 | 文字;
        optimum?: 数字;

        //@@{ 值:value }
        值?: 文字 | 文字[] | 数字;
    }

    接口 QuoteHTMLAttributes<T> 扩展 HTMLAttributes<T> {
        cite?: 文字;
    }

    接口 ObjectHTMLAttributes<T> 扩展 HTMLAttributes<T> {
        classID?: 文字;
        data?: 文字;
        form?: 文字;
        height?: 数字 | 文字;

        //@@{ 名称:name }
        名称?: 文字;

        //@@{ 类型:type }
        类型?: 文字;
        useMap?: 文字;
        width?: 数字 | 文字;
        wmode?: 文字;
    }

    接口 OlHTMLAttributes<T> 扩展 HTMLAttributes<T> {
        reversed?: 真假;
        start?: 数字;

        //@@{ 类型:type }
        类型?: '1' | 'a' | 'A' | 'i' | 'I';
    }

    接口 OptgroupHTMLAttributes<T> 扩展 HTMLAttributes<T> {
        disabled?: 真假;
        label?: 文字;
    }

    接口 OptionHTMLAttributes<T> 扩展 HTMLAttributes<T> {
        disabled?: 真假;
        label?: 文字;
        selected?: 真假;

        //@@{ 值:value }
        值?: 文字 | 文字[] | 数字;
    }

    接口 OutputHTMLAttributes<T> 扩展 HTMLAttributes<T> {
        form?: 文字;
        htmlFor?: 文字;

        //@@{ 名称:name }
        名称?: 文字;
    }

    接口 ParamHTMLAttributes<T> 扩展 HTMLAttributes<T> {

        //@@{ 名称:name }
        名称?: 文字;

        //@@{ 值:value }
        值?: 文字 | 文字[] | 数字;
    }

    接口 ProgressHTMLAttributes<T> 扩展 HTMLAttributes<T> {
        max?: 数字 | 文字;

        //@@{ 值:value }
        值?: 文字 | 文字[] | 数字;
    }

    接口 ScriptHTMLAttributes<T> 扩展 HTMLAttributes<T> {

        //@@{ 异步:async }
        异步?: 真假;
        charSet?: 文字;
        crossOrigin?: 文字;
        defer?: 真假;
        integrity?: 文字;
        noModule?: 真假;
        nonce?: 文字;
        src?: 文字;

        //@@{ 类型:type }
        类型?: 文字;
    }

    接口 SelectHTMLAttributes<T> 扩展 HTMLAttributes<T> {
        autoComplete?: 文字;
        autoFocus?: 真假;
        disabled?: 真假;
        form?: 文字;
        multiple?: 真假;

        //@@{ 名称:name }
        名称?: 文字;
        required?: 真假;
        size?: 数字;

        //@@{ 值:value }
        值?: 文字 | 文字[] | 数字;
        onChange?: ChangeEventHandler<T>;
    }

    接口 SourceHTMLAttributes<T> 扩展 HTMLAttributes<T> {
        media?: 文字;
        sizes?: 文字;
        src?: 文字;
        srcSet?: 文字;

        //@@{ 类型:type }
        类型?: 文字;
    }

    接口 StyleHTMLAttributes<T> 扩展 HTMLAttributes<T> {
        media?: 文字;
        nonce?: 文字;
        scoped?: 真假;

        //@@{ 类型:type }
        类型?: 文字;
    }

    接口 TableHTMLAttributes<T> 扩展 HTMLAttributes<T> {
        cellPadding?: 数字 | 文字;
        cellSpacing?: 数字 | 文字;
        summary?: 文字;
    }

    接口 TextareaHTMLAttributes<T> 扩展 HTMLAttributes<T> {
        autoComplete?: 文字;
        autoFocus?: 真假;
        cols?: 数字;
        dirName?: 文字;
        disabled?: 真假;
        form?: 文字;
        maxLength?: 数字;
        minLength?: 数字;

        //@@{ 名称:name }
        名称?: 文字;
        placeholder?: 文字;
        readOnly?: 真假;
        required?: 真假;
        rows?: 数字;

        //@@{ 值:value }
        值?: 文字 | 文字[] | 数字;
        wrap?: 文字;

        onChange?: ChangeEventHandler<T>;
    }

    接口 TdHTMLAttributes<T> 扩展 HTMLAttributes<T> {
        align?: "left" | "center" | "right" | "justify" | "char";
        colSpan?: 数字;
        headers?: 文字;
        rowSpan?: 数字;
        scope?: 文字;
    }

    接口 ThHTMLAttributes<T> 扩展 HTMLAttributes<T> {
        align?: "left" | "center" | "right" | "justify" | "char";
        colSpan?: 数字;
        headers?: 文字;
        rowSpan?: 数字;
        scope?: 文字;
    }

    接口 TimeHTMLAttributes<T> 扩展 HTMLAttributes<T> {
        dateTime?: 文字;
    }

    接口 TrackHTMLAttributes<T> 扩展 HTMLAttributes<T> {

        //@@{ 默认:default }
        默认?: 真假;
        kind?: 文字;
        label?: 文字;
        src?: 文字;
        srcLang?: 文字;
    }

    接口 VideoHTMLAttributes<T> 扩展 MediaHTMLAttributes<T> {
        height?: 数字 | 文字;
        playsInline?: 真假;
        poster?: 文字;
        width?: 数字 | 文字;
    }

    // this list is "complete" in that it contains every SVG attribute
    // that React supports, but the types can be improved.
    // Full list here: https://facebook.github.io/react/docs/dom-elements.html
    //
    // The three broad type categories are (in order of restrictiveness):
    //   - "number | string"
    //   - "string"
    //   - union of string literals
    接口 SVGAttributes<T> 扩展 AriaAttributes, DOMAttributes<T> {
        // Attributes which also defined in HTMLAttributes
        // See comment in SVGDOMPropertyConfig.js
        className?: 文字;
        color?: 文字;
        height?: 数字 | 文字;
        id?: 文字;
        lang?: 文字;
        max?: 数字 | 文字;
        media?: 文字;
        method?: 文字;
        min?: 数字 | 文字;

        //@@{ 名称:name }
        名称?: 文字;
        style?: CSSProperties;

        //@@{ 目标:target }
        目标?: 文字;

        //@@{ 类型:type }
        类型?: 文字;
        width?: 数字 | 文字;

        // Other HTML properties supported by SVG elements in browsers
        role?: 文字;
        tabIndex?: 数字;

        // SVG Specific attributes
        accentHeight?: 数字 | 文字;
        accumulate?: "none" | "sum";
        additive?: "replace" | "sum";
        alignmentBaseline?: "auto" | "baseline" | "before-edge" | "text-before-edge" | "middle" | "central" | "after-edge" |
        "text-after-edge" | "ideographic" | "alphabetic" | "hanging" | "mathematical" | "inherit";
        allowReorder?: "no" | "yes";
        alphabetic?: 数字 | 文字;
        amplitude?: 数字 | 文字;
        arabicForm?: "initial" | "medial" | "terminal" | "isolated";
        ascent?: 数字 | 文字;
        attributeName?: 文字;
        attributeType?: 文字;
        autoReverse?: 数字 | 文字;
        azimuth?: 数字 | 文字;
        baseFrequency?: 数字 | 文字;
        baselineShift?: 数字 | 文字;
        baseProfile?: 数字 | 文字;
        bbox?: 数字 | 文字;
        begin?: 数字 | 文字;
        bias?: 数字 | 文字;
        by?: 数字 | 文字;
        calcMode?: 数字 | 文字;
        capHeight?: 数字 | 文字;
        clip?: 数字 | 文字;
        clipPath?: 文字;
        clipPathUnits?: 数字 | 文字;
        clipRule?: 数字 | 文字;
        colorInterpolation?: 数字 | 文字;
        colorInterpolationFilters?: "auto" | "sRGB" | "linearRGB" | "inherit";
        colorProfile?: 数字 | 文字;
        colorRendering?: 数字 | 文字;
        contentScriptType?: 数字 | 文字;
        contentStyleType?: 数字 | 文字;
        cursor?: 数字 | 文字;
        cx?: 数字 | 文字;
        cy?: 数字 | 文字;
        d?: 文字;
        decelerate?: 数字 | 文字;
        descent?: 数字 | 文字;
        diffuseConstant?: 数字 | 文字;
        direction?: 数字 | 文字;
        display?: 数字 | 文字;
        divisor?: 数字 | 文字;
        dominantBaseline?: 数字 | 文字;
        dur?: 数字 | 文字;
        dx?: 数字 | 文字;
        dy?: 数字 | 文字;
        edgeMode?: 数字 | 文字;
        elevation?: 数字 | 文字;
        enableBackground?: 数字 | 文字;
        end?: 数字 | 文字;
        exponent?: 数字 | 文字;
        externalResourcesRequired?: 数字 | 文字;
        fill?: 文字;
        fillOpacity?: 数字 | 文字;
        fillRule?: "nonzero" | "evenodd" | "inherit";
        filter?: 文字;
        filterRes?: 数字 | 文字;
        filterUnits?: 数字 | 文字;
        floodColor?: 数字 | 文字;
        floodOpacity?: 数字 | 文字;
        focusable?: 数字 | 文字;
        fontFamily?: 文字;
        fontSize?: 数字 | 文字;
        fontSizeAdjust?: 数字 | 文字;
        fontStretch?: 数字 | 文字;
        fontStyle?: 数字 | 文字;
        fontVariant?: 数字 | 文字;
        fontWeight?: 数字 | 文字;
        format?: 数字 | 文字;

        //@@{ 来自:from }
        来自?: 数字 | 文字;
        fx?: 数字 | 文字;
        fy?: 数字 | 文字;
        g1?: 数字 | 文字;
        g2?: 数字 | 文字;
        glyphName?: 数字 | 文字;
        glyphOrientationHorizontal?: 数字 | 文字;
        glyphOrientationVertical?: 数字 | 文字;
        glyphRef?: 数字 | 文字;
        gradientTransform?: 文字;
        gradientUnits?: 文字;
        hanging?: 数字 | 文字;
        horizAdvX?: 数字 | 文字;
        horizOriginX?: 数字 | 文字;
        href?: 文字;
        ideographic?: 数字 | 文字;
        imageRendering?: 数字 | 文字;
        in2?: 数字 | 文字;

        //@@{ 位于:in }
        位于?: 文字;
        intercept?: 数字 | 文字;
        k1?: 数字 | 文字;
        k2?: 数字 | 文字;
        k3?: 数字 | 文字;
        k4?: 数字 | 文字;
        k?: 数字 | 文字;
        kernelMatrix?: 数字 | 文字;
        kernelUnitLength?: 数字 | 文字;
        kerning?: 数字 | 文字;
        keyPoints?: 数字 | 文字;
        keySplines?: 数字 | 文字;
        keyTimes?: 数字 | 文字;
        lengthAdjust?: 数字 | 文字;
        letterSpacing?: 数字 | 文字;
        lightingColor?: 数字 | 文字;
        limitingConeAngle?: 数字 | 文字;
        local?: 数字 | 文字;
        markerEnd?: 文字;
        markerHeight?: 数字 | 文字;
        markerMid?: 文字;
        markerStart?: 文字;
        markerUnits?: 数字 | 文字;
        markerWidth?: 数字 | 文字;
        mask?: 文字;
        maskContentUnits?: 数字 | 文字;
        maskUnits?: 数字 | 文字;
        mathematical?: 数字 | 文字;
        mode?: 数字 | 文字;
        numOctaves?: 数字 | 文字;
        offset?: 数字 | 文字;
        opacity?: 数字 | 文字;
        operator?: 数字 | 文字;
        order?: 数字 | 文字;
        orient?: 数字 | 文字;
        orientation?: 数字 | 文字;
        origin?: 数字 | 文字;
        overflow?: 数字 | 文字;
        overlinePosition?: 数字 | 文字;
        overlineThickness?: 数字 | 文字;
        paintOrder?: 数字 | 文字;
        panose1?: 数字 | 文字;
        pathLength?: 数字 | 文字;
        patternContentUnits?: 文字;
        patternTransform?: 数字 | 文字;
        patternUnits?: 文字;
        pointerEvents?: 数字 | 文字;
        points?: 文字;
        pointsAtX?: 数字 | 文字;
        pointsAtY?: 数字 | 文字;
        pointsAtZ?: 数字 | 文字;
        preserveAlpha?: 数字 | 文字;
        preserveAspectRatio?: 文字;
        primitiveUnits?: 数字 | 文字;
        r?: 数字 | 文字;
        radius?: 数字 | 文字;
        refX?: 数字 | 文字;
        refY?: 数字 | 文字;
        renderingIntent?: 数字 | 文字;
        repeatCount?: 数字 | 文字;
        repeatDur?: 数字 | 文字;
        requiredExtensions?: 数字 | 文字;
        requiredFeatures?: 数字 | 文字;
        restart?: 数字 | 文字;
        result?: 文字;
        rotate?: 数字 | 文字;
        rx?: 数字 | 文字;
        ry?: 数字 | 文字;
        scale?: 数字 | 文字;
        seed?: 数字 | 文字;
        shapeRendering?: 数字 | 文字;
        slope?: 数字 | 文字;
        spacing?: 数字 | 文字;
        specularConstant?: 数字 | 文字;
        specularExponent?: 数字 | 文字;
        speed?: 数字 | 文字;
        spreadMethod?: 文字;
        startOffset?: 数字 | 文字;
        stdDeviation?: 数字 | 文字;
        stemh?: 数字 | 文字;
        stemv?: 数字 | 文字;
        stitchTiles?: 数字 | 文字;
        stopColor?: 文字;
        stopOpacity?: 数字 | 文字;
        strikethroughPosition?: 数字 | 文字;
        strikethroughThickness?: 数字 | 文字;

        //@@{ 文字:string }
        文字?: 数字 | 文字;
        stroke?: 文字;
        strokeDasharray?: 文字 | 数字;
        strokeDashoffset?: 文字 | 数字;
        strokeLinecap?: "butt" | "round" | "square" | "inherit";
        strokeLinejoin?: "miter" | "round" | "bevel" | "inherit";
        strokeMiterlimit?: 数字 | 文字;
        strokeOpacity?: 数字 | 文字;
        strokeWidth?: 数字 | 文字;
        surfaceScale?: 数字 | 文字;
        systemLanguage?: 数字 | 文字;
        tableValues?: 数字 | 文字;
        targetX?: 数字 | 文字;
        targetY?: 数字 | 文字;
        textAnchor?: 文字;
        textDecoration?: 数字 | 文字;
        textLength?: 数字 | 文字;
        textRendering?: 数字 | 文字;
        to?: 数字 | 文字;
        transform?: 文字;
        u1?: 数字 | 文字;
        u2?: 数字 | 文字;
        underlinePosition?: 数字 | 文字;
        underlineThickness?: 数字 | 文字;
        unicode?: 数字 | 文字;
        unicodeBidi?: 数字 | 文字;
        unicodeRange?: 数字 | 文字;
        unitsPerEm?: 数字 | 文字;
        vAlphabetic?: 数字 | 文字;
        values?: 文字;
        vectorEffect?: 数字 | 文字;
        version?: 文字;
        vertAdvY?: 数字 | 文字;
        vertOriginX?: 数字 | 文字;
        vertOriginY?: 数字 | 文字;
        vHanging?: 数字 | 文字;
        vIdeographic?: 数字 | 文字;
        viewBox?: 文字;
        viewTarget?: 数字 | 文字;
        visibility?: 数字 | 文字;
        vMathematical?: 数字 | 文字;
        widths?: 数字 | 文字;
        wordSpacing?: 数字 | 文字;
        writingMode?: 数字 | 文字;
        x1?: 数字 | 文字;
        x2?: 数字 | 文字;
        x?: 数字 | 文字;
        xChannelSelector?: 文字;
        xHeight?: 数字 | 文字;
        xlinkActuate?: 文字;
        xlinkArcrole?: 文字;
        xlinkHref?: 文字;
        xlinkRole?: 文字;
        xlinkShow?: 文字;
        xlinkTitle?: 文字;
        xlinkType?: 文字;
        xmlBase?: 文字;
        xmlLang?: 文字;
        xmlns?: 文字;
        xmlnsXlink?: 文字;
        xmlSpace?: 文字;
        y1?: 数字 | 文字;
        y2?: 数字 | 文字;
        y?: 数字 | 文字;
        yChannelSelector?: 文字;
        z?: 数字 | 文字;
        zoomAndPan?: 文字;
    }

    接口 WebViewHTMLAttributes<T> 扩展 HTMLAttributes<T> {
        allowFullScreen?: 真假;
        allowpopups?: 真假;
        autoFocus?: 真假;
        autosize?: 真假;
        blinkfeatures?: 文字;
        disableblinkfeatures?: 文字;
        disableguestresize?: 真假;
        disablewebsecurity?: 真假;
        guestinstance?: 文字;
        httpreferrer?: 文字;
        nodeintegration?: 真假;
        partition?: 文字;
        plugins?: 真假;
        preload?: 文字;
        src?: 文字;
        useragent?: 文字;
        webpreferences?: 文字;
    }

    //
    // React.DOM
    // ----------------------------------------------------------------------

    接口 ReactHTML {

        //@@{ HTML超链接元素_:HTMLAnchorElement }
        a: DetailedHTMLFactory<AnchorHTMLAttributes<HTML超链接元素_>, HTML超链接元素_>;

        //@@{ HTML元素_:HTMLElement }
        abbr: DetailedHTMLFactory<HTMLAttributes<HTML元素_>, HTML元素_>;

        //@@{ HTML元素_:HTMLElement }
        address: DetailedHTMLFactory<HTMLAttributes<HTML元素_>, HTML元素_>;

        //@@{ HTML区域元素_:HTMLAreaElement }
        area: DetailedHTMLFactory<AreaHTMLAttributes<HTML区域元素_>, HTML区域元素_>;

        //@@{ HTML元素_:HTMLElement }
        article: DetailedHTMLFactory<HTMLAttributes<HTML元素_>, HTML元素_>;

        //@@{ HTML元素_:HTMLElement }
        aside: DetailedHTMLFactory<HTMLAttributes<HTML元素_>, HTML元素_>;

        //@@{ HTML音频元素_:HTMLAudioElement }
        audio: DetailedHTMLFactory<AudioHTMLAttributes<HTML音频元素_>, HTML音频元素_>;

        //@@{ HTML元素_:HTMLElement }
        b: DetailedHTMLFactory<HTMLAttributes<HTML元素_>, HTML元素_>;

        //@@{ HTML基元素_:HTMLBaseElement }
        base: DetailedHTMLFactory<BaseHTMLAttributes<HTML基元素_>, HTML基元素_>;

        //@@{ HTML元素_:HTMLElement }
        bdi: DetailedHTMLFactory<HTMLAttributes<HTML元素_>, HTML元素_>;

        //@@{ HTML元素_:HTMLElement }
        bdo: DetailedHTMLFactory<HTMLAttributes<HTML元素_>, HTML元素_>;

        //@@{ HTML元素_:HTMLElement }
        big: DetailedHTMLFactory<HTMLAttributes<HTML元素_>, HTML元素_>;

        //@@{ HTML元素_:HTMLElement }
        blockquote: DetailedHTMLFactory<BlockquoteHTMLAttributes<HTML元素_>, HTML元素_>;

        //@@{ HTML体元素_:HTMLBodyElement }
        body: DetailedHTMLFactory<HTMLAttributes<HTML体元素_>, HTML体元素_>;

        //@@{ HTML换行元素_:HTMLBRElement }
        br: DetailedHTMLFactory<HTMLAttributes<HTML换行元素_>, HTML换行元素_>;

        //@@{ HTML按钮元素_:HTMLButtonElement }
        button: DetailedHTMLFactory<ButtonHTMLAttributes<HTML按钮元素_>, HTML按钮元素_>;

        //@@{ HTML画板元素_:HTMLCanvasElement }
        canvas: DetailedHTMLFactory<CanvasHTMLAttributes<HTML画板元素_>, HTML画板元素_>;

        //@@{ HTML元素_:HTMLElement }
        caption: DetailedHTMLFactory<HTMLAttributes<HTML元素_>, HTML元素_>;

        //@@{ HTML元素_:HTMLElement }
        cite: DetailedHTMLFactory<HTMLAttributes<HTML元素_>, HTML元素_>;

        //@@{ HTML元素_:HTMLElement }
        code: DetailedHTMLFactory<HTMLAttributes<HTML元素_>, HTML元素_>;

        //@@{ HTML表列元素_:HTMLTableColElement }
        col: DetailedHTMLFactory<ColHTMLAttributes<HTML表列元素_>, HTML表列元素_>;

        //@@{ HTML表列元素_:HTMLTableColElement }
        colgroup: DetailedHTMLFactory<ColgroupHTMLAttributes<HTML表列元素_>, HTML表列元素_>;

        //@@{ HTML元素_:HTMLElement }
        data: DetailedHTMLFactory<HTMLAttributes<HTML元素_>, HTML元素_>;

        //@@{ HTML数据列表元素_:HTMLDataListElement }
        datalist: DetailedHTMLFactory<HTMLAttributes<HTML数据列表元素_>, HTML数据列表元素_>;

        //@@{ HTML元素_:HTMLElement }
        dd: DetailedHTMLFactory<HTMLAttributes<HTML元素_>, HTML元素_>;

        //@@{ HTML元素_:HTMLElement }
        del: DetailedHTMLFactory<DelHTMLAttributes<HTML元素_>, HTML元素_>;

        //@@{ HTML元素_:HTMLElement }
        details: DetailedHTMLFactory<DetailsHTMLAttributes<HTML元素_>, HTML元素_>;

        //@@{ HTML元素_:HTMLElement }
        dfn: DetailedHTMLFactory<HTMLAttributes<HTML元素_>, HTML元素_>;

        //@@{ HTML对话框元素_:HTMLDialogElement }
        dialog: DetailedHTMLFactory<DialogHTMLAttributes<HTML对话框元素_>, HTML对话框元素_>;

        //@@{ HTML块元素_:HTMLDivElement }
        div: DetailedHTMLFactory<HTMLAttributes<HTML块元素_>, HTML块元素_>;

        //@@{ HTML列表元素_:HTMLDListElement }
        dl: DetailedHTMLFactory<HTMLAttributes<HTML列表元素_>, HTML列表元素_>;

        //@@{ HTML元素_:HTMLElement }
        dt: DetailedHTMLFactory<HTMLAttributes<HTML元素_>, HTML元素_>;

        //@@{ HTML元素_:HTMLElement }
        em: DetailedHTMLFactory<HTMLAttributes<HTML元素_>, HTML元素_>;

        //@@{ HTML嵌入元素_:HTMLEmbedElement }
        embed: DetailedHTMLFactory<EmbedHTMLAttributes<HTML嵌入元素_>, HTML嵌入元素_>;

        //@@{ HTML分组元素_:HTMLFieldSetElement }
        fieldset: DetailedHTMLFactory<FieldsetHTMLAttributes<HTML分组元素_>, HTML分组元素_>;

        //@@{ HTML元素_:HTMLElement }
        figcaption: DetailedHTMLFactory<HTMLAttributes<HTML元素_>, HTML元素_>;

        //@@{ HTML元素_:HTMLElement }
        figure: DetailedHTMLFactory<HTMLAttributes<HTML元素_>, HTML元素_>;

        //@@{ HTML元素_:HTMLElement }
        footer: DetailedHTMLFactory<HTMLAttributes<HTML元素_>, HTML元素_>;

        //@@{ HTML表单元素_:HTMLFormElement }
        form: DetailedHTMLFactory<FormHTMLAttributes<HTML表单元素_>, HTML表单元素_>;

        //@@{ HTML标题头元素_:HTMLHeadingElement }
        h1: DetailedHTMLFactory<HTMLAttributes<HTML标题头元素_>, HTML标题头元素_>;

        //@@{ HTML标题头元素_:HTMLHeadingElement }
        h2: DetailedHTMLFactory<HTMLAttributes<HTML标题头元素_>, HTML标题头元素_>;

        //@@{ HTML标题头元素_:HTMLHeadingElement }
        h3: DetailedHTMLFactory<HTMLAttributes<HTML标题头元素_>, HTML标题头元素_>;

        //@@{ HTML标题头元素_:HTMLHeadingElement }
        h4: DetailedHTMLFactory<HTMLAttributes<HTML标题头元素_>, HTML标题头元素_>;

        //@@{ HTML标题头元素_:HTMLHeadingElement }
        h5: DetailedHTMLFactory<HTMLAttributes<HTML标题头元素_>, HTML标题头元素_>;

        //@@{ HTML标题头元素_:HTMLHeadingElement }
        h6: DetailedHTMLFactory<HTMLAttributes<HTML标题头元素_>, HTML标题头元素_>;

        //@@{ HTML元素_:HTMLElement, HTML头部元素_:HTMLHeadElement }
        head: DetailedHTMLFactory<HTMLAttributes<HTML元素_>, HTML头部元素_>;

        //@@{ HTML元素_:HTMLElement }
        header: DetailedHTMLFactory<HTMLAttributes<HTML元素_>, HTML元素_>;

        //@@{ HTML元素_:HTMLElement }
        hgroup: DetailedHTMLFactory<HTMLAttributes<HTML元素_>, HTML元素_>;

        //@@{ HTML水平线元素_:HTMLHRElement }
        hr: DetailedHTMLFactory<HTMLAttributes<HTML水平线元素_>, HTML水平线元素_>;

        //@@{ HTML超文本标记元素_:HTMLHtmlElement }
        html: DetailedHTMLFactory<HtmlHTMLAttributes<HTML超文本标记元素_>, HTML超文本标记元素_>;

        //@@{ HTML元素_:HTMLElement }
        i: DetailedHTMLFactory<HTMLAttributes<HTML元素_>, HTML元素_>;

        //@@{ HTML内联框架元素_:HTMLIFrameElement }
        iframe: DetailedHTMLFactory<IframeHTMLAttributes<HTML内联框架元素_>, HTML内联框架元素_>;

        //@@{ HTML图像元素_:HTMLImageElement }
        img: DetailedHTMLFactory<ImgHTMLAttributes<HTML图像元素_>, HTML图像元素_>;

        //@@{ HTML输入元素_:HTMLInputElement }
        input: DetailedHTMLFactory<InputHTMLAttributes<HTML输入元素_>, HTML输入元素_>;

        //@@{ HTML模块元素_:HTMLModElement }
        ins: DetailedHTMLFactory<InsHTMLAttributes<HTML模块元素_>, HTML模块元素_>;

        //@@{ HTML元素_:HTMLElement }
        kbd: DetailedHTMLFactory<HTMLAttributes<HTML元素_>, HTML元素_>;

        //@@{ HTML元素_:HTMLElement }
        keygen: DetailedHTMLFactory<KeygenHTMLAttributes<HTML元素_>, HTML元素_>;

        //@@{ HTML标签元素_:HTMLLabelElement }
        label: DetailedHTMLFactory<LabelHTMLAttributes<HTML标签元素_>, HTML标签元素_>;

        //@@{ HTML分组标题元素_:HTMLLegendElement }
        legend: DetailedHTMLFactory<HTMLAttributes<HTML分组标题元素_>, HTML分组标题元素_>;

        //@@{ HTML列表项元素_:HTMLLIElement }
        li: DetailedHTMLFactory<LiHTMLAttributes<HTML列表项元素_>, HTML列表项元素_>;

        //@@{ 链接:link, HTML外部样式元素_:HTMLLinkElement }
        链接: DetailedHTMLFactory<LinkHTMLAttributes<HTML外部样式元素_>, HTML外部样式元素_>;

        //@@{ HTML元素_:HTMLElement }
        main: DetailedHTMLFactory<HTMLAttributes<HTML元素_>, HTML元素_>;

        //@@{ HTML图像映射元素_:HTMLMapElement }
        map: DetailedHTMLFactory<MapHTMLAttributes<HTML图像映射元素_>, HTML图像映射元素_>;

        //@@{ HTML元素_:HTMLElement }
        mark: DetailedHTMLFactory<HTMLAttributes<HTML元素_>, HTML元素_>;

        //@@{ HTML元素_:HTMLElement }
        menu: DetailedHTMLFactory<MenuHTMLAttributes<HTML元素_>, HTML元素_>;

        //@@{ HTML元素_:HTMLElement }
        menuitem: DetailedHTMLFactory<HTMLAttributes<HTML元素_>, HTML元素_>;

        //@@{ 元数据:meta, HTML元数据元素_:HTMLMetaElement }
        元数据: DetailedHTMLFactory<MetaHTMLAttributes<HTML元数据元素_>, HTML元数据元素_>;

        //@@{ HTML元素_:HTMLElement }
        meter: DetailedHTMLFactory<MeterHTMLAttributes<HTML元素_>, HTML元素_>;

        //@@{ HTML元素_:HTMLElement }
        nav: DetailedHTMLFactory<HTMLAttributes<HTML元素_>, HTML元素_>;

        //@@{ HTML元素_:HTMLElement }
        noscript: DetailedHTMLFactory<HTMLAttributes<HTML元素_>, HTML元素_>;

        //@@{ 对象:object, HTML对象元素_:HTMLObjectElement }
        对象: DetailedHTMLFactory<ObjectHTMLAttributes<HTML对象元素_>, HTML对象元素_>;

        //@@{ HTML有序列表元素_:HTMLOListElement }
        ol: DetailedHTMLFactory<OlHTMLAttributes<HTML有序列表元素_>, HTML有序列表元素_>;

        //@@{ HTML选项组元素_:HTMLOptGroupElement }
        optgroup: DetailedHTMLFactory<OptgroupHTMLAttributes<HTML选项组元素_>, HTML选项组元素_>;

        //@@{ HTML选项元素_:HTMLOptionElement }
        option: DetailedHTMLFactory<OptionHTMLAttributes<HTML选项元素_>, HTML选项元素_>;

        //@@{ HTML元素_:HTMLElement }
        output: DetailedHTMLFactory<OutputHTMLAttributes<HTML元素_>, HTML元素_>;

        //@@{ HTML段落元素_:HTMLParagraphElement }
        p: DetailedHTMLFactory<HTMLAttributes<HTML段落元素_>, HTML段落元素_>;

        //@@{ 参数:param, HTML参数元素_:HTMLParamElement }
        参数: DetailedHTMLFactory<ParamHTMLAttributes<HTML参数元素_>, HTML参数元素_>;

        //@@{ HTML元素_:HTMLElement }
        picture: DetailedHTMLFactory<HTMLAttributes<HTML元素_>, HTML元素_>;

        //@@{ HTML预处理元素_:HTMLPreElement }
        pre: DetailedHTMLFactory<HTMLAttributes<HTML预处理元素_>, HTML预处理元素_>;

        //@@{ HTML进度元素_:HTMLProgressElement }
        progress: DetailedHTMLFactory<ProgressHTMLAttributes<HTML进度元素_>, HTML进度元素_>;

        //@@{ HTML引用元素_:HTMLQuoteElement }
        q: DetailedHTMLFactory<QuoteHTMLAttributes<HTML引用元素_>, HTML引用元素_>;

        //@@{ HTML元素_:HTMLElement }
        rp: DetailedHTMLFactory<HTMLAttributes<HTML元素_>, HTML元素_>;

        //@@{ HTML元素_:HTMLElement }
        rt: DetailedHTMLFactory<HTMLAttributes<HTML元素_>, HTML元素_>;

        //@@{ HTML元素_:HTMLElement }
        ruby: DetailedHTMLFactory<HTMLAttributes<HTML元素_>, HTML元素_>;

        //@@{ HTML元素_:HTMLElement }
        s: DetailedHTMLFactory<HTMLAttributes<HTML元素_>, HTML元素_>;

        //@@{ HTML元素_:HTMLElement }
        samp: DetailedHTMLFactory<HTMLAttributes<HTML元素_>, HTML元素_>;

        //@@{ HTML脚本元素_:HTMLScriptElement }
        script: DetailedHTMLFactory<ScriptHTMLAttributes<HTML脚本元素_>, HTML脚本元素_>;

        //@@{ HTML元素_:HTMLElement }
        section: DetailedHTMLFactory<HTMLAttributes<HTML元素_>, HTML元素_>;

        //@@{ HTML选择元素_:HTMLSelectElement }
        select: DetailedHTMLFactory<SelectHTMLAttributes<HTML选择元素_>, HTML选择元素_>;

        //@@{ HTML元素_:HTMLElement }
        small: DetailedHTMLFactory<HTMLAttributes<HTML元素_>, HTML元素_>;

        //@@{ HTML来源元素_:HTMLSourceElement }
        source: DetailedHTMLFactory<SourceHTMLAttributes<HTML来源元素_>, HTML来源元素_>;

        //@@{ HTML跨度元素_:HTMLSpanElement }
        span: DetailedHTMLFactory<HTMLAttributes<HTML跨度元素_>, HTML跨度元素_>;

        //@@{ HTML元素_:HTMLElement }
        strong: DetailedHTMLFactory<HTMLAttributes<HTML元素_>, HTML元素_>;

        //@@{ HTML样式元素_:HTMLStyleElement }
        style: DetailedHTMLFactory<StyleHTMLAttributes<HTML样式元素_>, HTML样式元素_>;

        //@@{ HTML元素_:HTMLElement }
        sub: DetailedHTMLFactory<HTMLAttributes<HTML元素_>, HTML元素_>;

        //@@{ HTML元素_:HTMLElement }
        summary: DetailedHTMLFactory<HTMLAttributes<HTML元素_>, HTML元素_>;

        //@@{ HTML元素_:HTMLElement }
        sup: DetailedHTMLFactory<HTMLAttributes<HTML元素_>, HTML元素_>;

        //@@{ HTML表元素_:HTMLTableElement }
        table: DetailedHTMLFactory<TableHTMLAttributes<HTML表元素_>, HTML表元素_>;

        //@@{ HTML表部分元素_:HTMLTableSectionElement }
        tbody: DetailedHTMLFactory<HTMLAttributes<HTML表部分元素_>, HTML表部分元素_>;

        //@@{ HTML表数据单元格元素_:HTMLTableDataCellElement }
        td: DetailedHTMLFactory<TdHTMLAttributes<HTML表数据单元格元素_>, HTML表数据单元格元素_>;

        //@@{ HTML文本区域元素_:HTMLTextAreaElement }
        textarea: DetailedHTMLFactory<TextareaHTMLAttributes<HTML文本区域元素_>, HTML文本区域元素_>;

        //@@{ HTML表部分元素_:HTMLTableSectionElement }
        tfoot: DetailedHTMLFactory<HTMLAttributes<HTML表部分元素_>, HTML表部分元素_>;

        //@@{ HTML表头单元格_:HTMLTableHeaderCellElement }
        th: DetailedHTMLFactory<ThHTMLAttributes<HTML表头单元格_>, HTML表头单元格_>;

        //@@{ HTML表部分元素_:HTMLTableSectionElement }
        thead: DetailedHTMLFactory<HTMLAttributes<HTML表部分元素_>, HTML表部分元素_>;

        //@@{ HTML元素_:HTMLElement }
        time: DetailedHTMLFactory<TimeHTMLAttributes<HTML元素_>, HTML元素_>;

        //@@{ HTML标题元素_:HTMLTitleElement }
        title: DetailedHTMLFactory<HTMLAttributes<HTML标题元素_>, HTML标题元素_>;

        //@@{ HTML表行元素_:HTMLTableRowElement }
        tr: DetailedHTMLFactory<HTMLAttributes<HTML表行元素_>, HTML表行元素_>;

        //@@{ HTML轨道元素_:HTMLTrackElement }
        track: DetailedHTMLFactory<TrackHTMLAttributes<HTML轨道元素_>, HTML轨道元素_>;

        //@@{ HTML元素_:HTMLElement }
        u: DetailedHTMLFactory<HTMLAttributes<HTML元素_>, HTML元素_>;

        //@@{ HTML无序列表元素_:HTMLUListElement }
        ul: DetailedHTMLFactory<HTMLAttributes<HTML无序列表元素_>, HTML无序列表元素_>;

        //@@{ "定义":"var", HTML元素_:HTMLElement }
        "定义": DetailedHTMLFactory<HTMLAttributes<HTML元素_>, HTML元素_>;

        //@@{ HTML视频元素_:HTMLVideoElement }
        video: DetailedHTMLFactory<VideoHTMLAttributes<HTML视频元素_>, HTML视频元素_>;

        //@@{ HTML元素_:HTMLElement }
        wbr: DetailedHTMLFactory<HTMLAttributes<HTML元素_>, HTML元素_>;
        webview: DetailedHTMLFactory<WebViewHTMLAttributes<HTMLWebViewElement>, HTMLWebViewElement>;
    }

    接口 ReactSVG {
        animate: SVGFactory;
        circle: SVGFactory;
        clipPath: SVGFactory;
        defs: SVGFactory;
        desc: SVGFactory;
        ellipse: SVGFactory;
        feBlend: SVGFactory;
        feColorMatrix: SVGFactory;
        feComponentTransfer: SVGFactory;
        feComposite: SVGFactory;
        feConvolveMatrix: SVGFactory;
        feDiffuseLighting: SVGFactory;
        feDisplacementMap: SVGFactory;
        feDistantLight: SVGFactory;
        feDropShadow: SVGFactory;
        feFlood: SVGFactory;
        feFuncA: SVGFactory;
        feFuncB: SVGFactory;
        feFuncG: SVGFactory;
        feFuncR: SVGFactory;
        feGaussianBlur: SVGFactory;
        feImage: SVGFactory;
        feMerge: SVGFactory;
        feMergeNode: SVGFactory;
        feMorphology: SVGFactory;
        feOffset: SVGFactory;
        fePointLight: SVGFactory;
        feSpecularLighting: SVGFactory;
        feSpotLight: SVGFactory;
        feTile: SVGFactory;
        feTurbulence: SVGFactory;
        filter: SVGFactory;
        foreignObject: SVGFactory;
        g: SVGFactory;
        image: SVGFactory;
        line: SVGFactory;
        linearGradient: SVGFactory;
        marker: SVGFactory;
        mask: SVGFactory;
        metadata: SVGFactory;

        //@@{ 路径:path }
        路径: SVGFactory;
        pattern: SVGFactory;
        polygon: SVGFactory;
        polyline: SVGFactory;
        radialGradient: SVGFactory;
        rect: SVGFactory;
        stop: SVGFactory;
        svg: SVGFactory;

        //@@{ 假如:switch }
        假如: SVGFactory;

        //@@{ 符号:symbol }
        符号: SVGFactory;
        text: SVGFactory;
        textPath: SVGFactory;
        tspan: SVGFactory;
        use: SVGFactory;
        view: SVGFactory;
    }

    接口 ReactDOM 扩展 ReactHTML, ReactSVG { }

    //
    // React.PropTypes
    // ----------------------------------------------------------------------

    类型 Validator<T> = PropTypes.Validator<T>;

    类型 Requireable<T> = PropTypes.Requireable<T>;

    类型 ValidationMap<T> = PropTypes.ValidationMap<T>;

    类型 WeakValidationMap<T> = {
        [K 位于 键为 T]?: 空值 扩展 T[K]
            ? Validator<T[K] | 空值 | 未定>
            : 未定 扩展 T[K]
            ? Validator<T[K] | 空值 | 未定>
            : Validator<T[K]>
    };

    接口 ReactPropTypes {

        //@@{ 任意:any }
        任意: 类为 PropTypes.任意;

        //@@{ 数组:array }
        数组: 类为 PropTypes.数组;
        bool: 类为 PropTypes.bool;
        func: 类为 PropTypes.func;

        //@@{ 数字:number }
        数字: 类为 PropTypes.数字;

        //@@{ 对象:object }
        对象: 类为 PropTypes.对象;

        //@@{ 文字:string }
        文字: 类为 PropTypes.文字;
        node: 类为 PropTypes.node;

        //@@{ 元素:element }
        元素: 类为 PropTypes.元素;
        instanceOf: 类为 PropTypes.instanceOf;
        oneOf: 类为 PropTypes.oneOf;
        oneOfType: 类为 PropTypes.oneOfType;
        arrayOf: 类为 PropTypes.arrayOf;
        objectOf: 类为 PropTypes.objectOf;
        shape: 类为 PropTypes.shape;
        exact: 类为 PropTypes.exact;
    }

    //
    // React.Children
    // ----------------------------------------------------------------------

    接口 ReactChildren {
        map<T, C>(子属性: C | C[], fn: (child: C, index: 数字) => T): T[];
        forEach<C>(子属性: C | C[], fn: (child: C, index: 数字) => 无值): 无值;
        count(子属性: 任意): 数字;
        only<C>(子属性: C): C 扩展 任意[] ? 不及 : C;
        toArray<C>(子属性: C | C[]): C[];
    }

    //
    // Browser Interfaces
    // https://github.com/nikeee/2048-typescript/blob/master/2048/js/touch.d.ts
    // ----------------------------------------------------------------------

    接口 AbstractView {

        //@@{ 样式媒体_:StyleMedia }
        styleMedia: 样式媒体_;

        //@@{ 文档:document, 文档_:Document }
        文档: 文档_;
    }

    接口 Touch {
        identifier: 数字;

        //@@{ 目标:target, 事件目标_:EventTarget }
        目标: 事件目标_;
        screenX: 数字;
        screenY: 数字;
        clientX: 数字;
        clientY: 数字;
        pageX: 数字;
        pageY: 数字;
    }

    接口 TouchList {
        [index: 数字]: Touch;

        //@@{ 长度:length }
        长度: 数字;
        item(index: 数字): Touch;
        identifiedTouch(identifier: 数字): Touch;
    }

    //
    // Error Interfaces
    // ----------------------------------------------------------------------
    接口 ErrorInfo {
        /**
         * Captures which component contained the exception, and its ancestors.
         */
        componentStack: 文字;
    }
}

// naked 'any' type in a conditional type will short circuit and union both the then/else branches
// so boolean is only resolved for T = any
类型 IsExactlyAny<T> = 真假 扩展 (T 扩展 不及 ? 为真 : 为假) ? 为真 : 为假;

类型 ExactlyAnyPropertyKeys<T> = { [K 位于 键为 T]: IsExactlyAny<T[K]> 扩展 为真 ? K : 不及 }[键为 T];

//@@{ 排除_:Exclude }
类型 NotExactlyAnyPropertyKeys<T> = 排除_<键为 T, ExactlyAnyPropertyKeys<T>>;

// Try to resolve ill-defined props like for JS users: props can be any, or sometimes objects with properties of type any
类型 MergePropTypes<P, T> =
    // If props is type any, use propTypes definitions
    IsExactlyAny<P> 扩展 为真 ? T :
        // If declared props have indexed properties, ignore inferred props entirely as keyof gets widened
        文字 扩展 键为 P ? P :
            // Prefer declared types which are not exactly any

            //@@{ 挑选_:Pick }
            & 挑选_<P, NotExactlyAnyPropertyKeys<P>>
            // For props which are exactly any, use the type inferred from propTypes if present

            //@@{ 挑选_:Pick, 排除_:Exclude }
            & 挑选_<T, 排除_<键为 T, NotExactlyAnyPropertyKeys<P>>>
            // Keep leftover props not specified in propTypes

            //@@{ 挑选_:Pick, 排除_:Exclude }
            & 挑选_<P, 排除_<键为 P, 键为 T>>;

// Any prop that has a default prop becomes optional, but its type is unchanged
// Undeclared default props are augmented into the resulting allowable attributes
// If declared props have indexed properties, ignore default props entirely as keyof gets widened
// Wrap in an outer-level conditional type to allow distribution over props that are unions
类型 Defaultize<P, D> = P 扩展 任意
    ? 文字 扩展 键为 P ? P :

        //@@{ 挑选_:Pick, 排除_:Exclude }
        & 挑选_<P, 排除_<键为 P, 键为 D>>

        //@@{ 可选_:Partial, 挑选_:Pick, 压榨_:Extract }
        & 可选_<挑选_<P, 压榨_<键为 P, 键为 D>>>

        //@@{ 可选_:Partial, 挑选_:Pick, 排除_:Exclude }
        & 可选_<挑选_<D, 排除_<键为 D, 键为 P>>>
    : 不及;

类型 ReactManagedAttributes<C, P> = C 扩展 { propTypes: 推断 T; defaultProps: 推断 D; }
    ? Defaultize<MergePropTypes<P, PropTypes.InferProps<T>>, D>
    : C 扩展 { propTypes: 推断 T; }
        ? MergePropTypes<P, PropTypes.InferProps<T>>
        : C 扩展 { defaultProps: 推断 D; }
            ? Defaultize<P, D>
            : P;

//@@{ 全局:global }
声明 全局 {
    名域 JSX {
        // tslint:disable-next-line:no-empty-interface

        //@@{ 元素_:Element }
        接口 元素_ 扩展 React.ReactElement<任意, 任意> { }

        //@@{ 元素类_:ElementClass }
        接口 元素类_ 扩展 React.Component<任意> {
            render(): React.ReactNode;
        }

        //@@{ 元素特性属性_:ElementAttributesProperty, 属性组:props }
        接口 元素特性属性_ { 属性组: {}; }

        //@@{ 子属性:children }
        接口 ElementChildrenAttribute { 子属性: {}; }

        // We can't recurse forever because `type` can't be self-referential;
        // let's assume it's reasonable to do a single React.lazy() around a single React.memo() / vice-versa
        类型 LibraryManagedAttributes<C, P> = C 扩展 React.MemoExoticComponent<推断 T> | React.LazyExoticComponent<推断 T>
            ? T 扩展 React.MemoExoticComponent<推断 U> | React.LazyExoticComponent<推断 U>
                ? ReactManagedAttributes<U, P>
                : ReactManagedAttributes<T, P>
            : ReactManagedAttributes<C, P>;

        // tslint:disable-next-line:no-empty-interface
        接口 IntrinsicAttributes 扩展 React.Attributes { }
        // tslint:disable-next-line:no-empty-interface
        接口 IntrinsicClassAttributes<T> 扩展 React.ClassAttributes<T> { }

        //@@{ 内置元素_:IntrinsicElements }
        接口 内置元素_ {
            // HTML

            //@@{ HTML超链接元素_:HTMLAnchorElement }
            a: React.DetailedHTMLProps<React.AnchorHTMLAttributes<HTML超链接元素_>, HTML超链接元素_>;

            //@@{ HTML元素_:HTMLElement }
            abbr: React.DetailedHTMLProps<React.HTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ HTML元素_:HTMLElement }
            address: React.DetailedHTMLProps<React.HTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ HTML区域元素_:HTMLAreaElement }
            area: React.DetailedHTMLProps<React.AreaHTMLAttributes<HTML区域元素_>, HTML区域元素_>;

            //@@{ HTML元素_:HTMLElement }
            article: React.DetailedHTMLProps<React.HTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ HTML元素_:HTMLElement }
            aside: React.DetailedHTMLProps<React.HTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ HTML音频元素_:HTMLAudioElement }
            audio: React.DetailedHTMLProps<React.AudioHTMLAttributes<HTML音频元素_>, HTML音频元素_>;

            //@@{ HTML元素_:HTMLElement }
            b: React.DetailedHTMLProps<React.HTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ HTML基元素_:HTMLBaseElement }
            base: React.DetailedHTMLProps<React.BaseHTMLAttributes<HTML基元素_>, HTML基元素_>;

            //@@{ HTML元素_:HTMLElement }
            bdi: React.DetailedHTMLProps<React.HTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ HTML元素_:HTMLElement }
            bdo: React.DetailedHTMLProps<React.HTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ HTML元素_:HTMLElement }
            big: React.DetailedHTMLProps<React.HTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ HTML元素_:HTMLElement }
            blockquote: React.DetailedHTMLProps<React.BlockquoteHTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ HTML体元素_:HTMLBodyElement }
            body: React.DetailedHTMLProps<React.HTMLAttributes<HTML体元素_>, HTML体元素_>;

            //@@{ HTML换行元素_:HTMLBRElement }
            br: React.DetailedHTMLProps<React.HTMLAttributes<HTML换行元素_>, HTML换行元素_>;

            //@@{ HTML按钮元素_:HTMLButtonElement }
            button: React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTML按钮元素_>, HTML按钮元素_>;

            //@@{ HTML画板元素_:HTMLCanvasElement }
            canvas: React.DetailedHTMLProps<React.CanvasHTMLAttributes<HTML画板元素_>, HTML画板元素_>;

            //@@{ HTML元素_:HTMLElement }
            caption: React.DetailedHTMLProps<React.HTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ HTML元素_:HTMLElement }
            cite: React.DetailedHTMLProps<React.HTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ HTML元素_:HTMLElement }
            code: React.DetailedHTMLProps<React.HTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ HTML表列元素_:HTMLTableColElement }
            col: React.DetailedHTMLProps<React.ColHTMLAttributes<HTML表列元素_>, HTML表列元素_>;

            //@@{ HTML表列元素_:HTMLTableColElement }
            colgroup: React.DetailedHTMLProps<React.ColgroupHTMLAttributes<HTML表列元素_>, HTML表列元素_>;

            //@@{ HTML元素_:HTMLElement }
            data: React.DetailedHTMLProps<React.HTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ HTML数据列表元素_:HTMLDataListElement }
            datalist: React.DetailedHTMLProps<React.HTMLAttributes<HTML数据列表元素_>, HTML数据列表元素_>;

            //@@{ HTML元素_:HTMLElement }
            dd: React.DetailedHTMLProps<React.HTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ HTML元素_:HTMLElement }
            del: React.DetailedHTMLProps<React.DelHTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ HTML元素_:HTMLElement }
            details: React.DetailedHTMLProps<React.DetailsHTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ HTML元素_:HTMLElement }
            dfn: React.DetailedHTMLProps<React.HTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ HTML对话框元素_:HTMLDialogElement }
            dialog: React.DetailedHTMLProps<React.DialogHTMLAttributes<HTML对话框元素_>, HTML对话框元素_>;

            //@@{ HTML块元素_:HTMLDivElement }
            div: React.DetailedHTMLProps<React.HTMLAttributes<HTML块元素_>, HTML块元素_>;

            //@@{ HTML列表元素_:HTMLDListElement }
            dl: React.DetailedHTMLProps<React.HTMLAttributes<HTML列表元素_>, HTML列表元素_>;

            //@@{ HTML元素_:HTMLElement }
            dt: React.DetailedHTMLProps<React.HTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ HTML元素_:HTMLElement }
            em: React.DetailedHTMLProps<React.HTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ HTML嵌入元素_:HTMLEmbedElement }
            embed: React.DetailedHTMLProps<React.EmbedHTMLAttributes<HTML嵌入元素_>, HTML嵌入元素_>;

            //@@{ HTML分组元素_:HTMLFieldSetElement }
            fieldset: React.DetailedHTMLProps<React.FieldsetHTMLAttributes<HTML分组元素_>, HTML分组元素_>;

            //@@{ HTML元素_:HTMLElement }
            figcaption: React.DetailedHTMLProps<React.HTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ HTML元素_:HTMLElement }
            figure: React.DetailedHTMLProps<React.HTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ HTML元素_:HTMLElement }
            footer: React.DetailedHTMLProps<React.HTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ HTML表单元素_:HTMLFormElement }
            form: React.DetailedHTMLProps<React.FormHTMLAttributes<HTML表单元素_>, HTML表单元素_>;

            //@@{ HTML标题头元素_:HTMLHeadingElement }
            h1: React.DetailedHTMLProps<React.HTMLAttributes<HTML标题头元素_>, HTML标题头元素_>;

            //@@{ HTML标题头元素_:HTMLHeadingElement }
            h2: React.DetailedHTMLProps<React.HTMLAttributes<HTML标题头元素_>, HTML标题头元素_>;

            //@@{ HTML标题头元素_:HTMLHeadingElement }
            h3: React.DetailedHTMLProps<React.HTMLAttributes<HTML标题头元素_>, HTML标题头元素_>;

            //@@{ HTML标题头元素_:HTMLHeadingElement }
            h4: React.DetailedHTMLProps<React.HTMLAttributes<HTML标题头元素_>, HTML标题头元素_>;

            //@@{ HTML标题头元素_:HTMLHeadingElement }
            h5: React.DetailedHTMLProps<React.HTMLAttributes<HTML标题头元素_>, HTML标题头元素_>;

            //@@{ HTML标题头元素_:HTMLHeadingElement }
            h6: React.DetailedHTMLProps<React.HTMLAttributes<HTML标题头元素_>, HTML标题头元素_>;

            //@@{ HTML头部元素_:HTMLHeadElement }
            head: React.DetailedHTMLProps<React.HTMLAttributes<HTML头部元素_>, HTML头部元素_>;

            //@@{ HTML元素_:HTMLElement }
            header: React.DetailedHTMLProps<React.HTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ HTML元素_:HTMLElement }
            hgroup: React.DetailedHTMLProps<React.HTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ HTML水平线元素_:HTMLHRElement }
            hr: React.DetailedHTMLProps<React.HTMLAttributes<HTML水平线元素_>, HTML水平线元素_>;

            //@@{ HTML超文本标记元素_:HTMLHtmlElement }
            html: React.DetailedHTMLProps<React.HtmlHTMLAttributes<HTML超文本标记元素_>, HTML超文本标记元素_>;

            //@@{ HTML元素_:HTMLElement }
            i: React.DetailedHTMLProps<React.HTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ HTML内联框架元素_:HTMLIFrameElement }
            iframe: React.DetailedHTMLProps<React.IframeHTMLAttributes<HTML内联框架元素_>, HTML内联框架元素_>;

            //@@{ HTML图像元素_:HTMLImageElement }
            img: React.DetailedHTMLProps<React.ImgHTMLAttributes<HTML图像元素_>, HTML图像元素_>;

            //@@{ HTML输入元素_:HTMLInputElement }
            input: React.DetailedHTMLProps<React.InputHTMLAttributes<HTML输入元素_>, HTML输入元素_>;

            //@@{ HTML模块元素_:HTMLModElement }
            ins: React.DetailedHTMLProps<React.InsHTMLAttributes<HTML模块元素_>, HTML模块元素_>;

            //@@{ HTML元素_:HTMLElement }
            kbd: React.DetailedHTMLProps<React.HTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ HTML元素_:HTMLElement }
            keygen: React.DetailedHTMLProps<React.KeygenHTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ HTML标签元素_:HTMLLabelElement }
            label: React.DetailedHTMLProps<React.LabelHTMLAttributes<HTML标签元素_>, HTML标签元素_>;

            //@@{ HTML分组标题元素_:HTMLLegendElement }
            legend: React.DetailedHTMLProps<React.HTMLAttributes<HTML分组标题元素_>, HTML分组标题元素_>;

            //@@{ HTML列表项元素_:HTMLLIElement }
            li: React.DetailedHTMLProps<React.LiHTMLAttributes<HTML列表项元素_>, HTML列表项元素_>;

            //@@{ 链接:link, HTML外部样式元素_:HTMLLinkElement }
            链接: React.DetailedHTMLProps<React.LinkHTMLAttributes<HTML外部样式元素_>, HTML外部样式元素_>;

            //@@{ HTML元素_:HTMLElement }
            main: React.DetailedHTMLProps<React.HTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ HTML图像映射元素_:HTMLMapElement }
            map: React.DetailedHTMLProps<React.MapHTMLAttributes<HTML图像映射元素_>, HTML图像映射元素_>;

            //@@{ HTML元素_:HTMLElement }
            mark: React.DetailedHTMLProps<React.HTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ HTML元素_:HTMLElement }
            menu: React.DetailedHTMLProps<React.MenuHTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ HTML元素_:HTMLElement }
            menuitem: React.DetailedHTMLProps<React.HTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ 元数据:meta, HTML元数据元素_:HTMLMetaElement }
            元数据: React.DetailedHTMLProps<React.MetaHTMLAttributes<HTML元数据元素_>, HTML元数据元素_>;

            //@@{ HTML元素_:HTMLElement }
            meter: React.DetailedHTMLProps<React.MeterHTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ HTML元素_:HTMLElement }
            nav: React.DetailedHTMLProps<React.HTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ HTML元素_:HTMLElement }
            noindex: React.DetailedHTMLProps<React.HTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ HTML元素_:HTMLElement }
            noscript: React.DetailedHTMLProps<React.HTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ 对象:object, HTML对象元素_:HTMLObjectElement }
            对象: React.DetailedHTMLProps<React.ObjectHTMLAttributes<HTML对象元素_>, HTML对象元素_>;

            //@@{ HTML有序列表元素_:HTMLOListElement }
            ol: React.DetailedHTMLProps<React.OlHTMLAttributes<HTML有序列表元素_>, HTML有序列表元素_>;

            //@@{ HTML选项组元素_:HTMLOptGroupElement }
            optgroup: React.DetailedHTMLProps<React.OptgroupHTMLAttributes<HTML选项组元素_>, HTML选项组元素_>;

            //@@{ HTML选项元素_:HTMLOptionElement }
            option: React.DetailedHTMLProps<React.OptionHTMLAttributes<HTML选项元素_>, HTML选项元素_>;

            //@@{ HTML元素_:HTMLElement }
            output: React.DetailedHTMLProps<React.OutputHTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ HTML段落元素_:HTMLParagraphElement }
            p: React.DetailedHTMLProps<React.HTMLAttributes<HTML段落元素_>, HTML段落元素_>;

            //@@{ 参数:param, HTML参数元素_:HTMLParamElement }
            参数: React.DetailedHTMLProps<React.ParamHTMLAttributes<HTML参数元素_>, HTML参数元素_>;

            //@@{ HTML元素_:HTMLElement }
            picture: React.DetailedHTMLProps<React.HTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ HTML预处理元素_:HTMLPreElement }
            pre: React.DetailedHTMLProps<React.HTMLAttributes<HTML预处理元素_>, HTML预处理元素_>;

            //@@{ HTML进度元素_:HTMLProgressElement }
            progress: React.DetailedHTMLProps<React.ProgressHTMLAttributes<HTML进度元素_>, HTML进度元素_>;

            //@@{ HTML引用元素_:HTMLQuoteElement }
            q: React.DetailedHTMLProps<React.QuoteHTMLAttributes<HTML引用元素_>, HTML引用元素_>;

            //@@{ HTML元素_:HTMLElement }
            rp: React.DetailedHTMLProps<React.HTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ HTML元素_:HTMLElement }
            rt: React.DetailedHTMLProps<React.HTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ HTML元素_:HTMLElement }
            ruby: React.DetailedHTMLProps<React.HTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ HTML元素_:HTMLElement }
            s: React.DetailedHTMLProps<React.HTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ HTML元素_:HTMLElement }
            samp: React.DetailedHTMLProps<React.HTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ HTML脚本元素_:HTMLScriptElement }
            script: React.DetailedHTMLProps<React.ScriptHTMLAttributes<HTML脚本元素_>, HTML脚本元素_>;

            //@@{ HTML元素_:HTMLElement }
            section: React.DetailedHTMLProps<React.HTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ HTML选择元素_:HTMLSelectElement }
            select: React.DetailedHTMLProps<React.SelectHTMLAttributes<HTML选择元素_>, HTML选择元素_>;

            //@@{ HTML元素_:HTMLElement }
            small: React.DetailedHTMLProps<React.HTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ HTML来源元素_:HTMLSourceElement }
            source: React.DetailedHTMLProps<React.SourceHTMLAttributes<HTML来源元素_>, HTML来源元素_>;

            //@@{ HTML跨度元素_:HTMLSpanElement }
            span: React.DetailedHTMLProps<React.HTMLAttributes<HTML跨度元素_>, HTML跨度元素_>;

            //@@{ HTML元素_:HTMLElement }
            strong: React.DetailedHTMLProps<React.HTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ HTML样式元素_:HTMLStyleElement }
            style: React.DetailedHTMLProps<React.StyleHTMLAttributes<HTML样式元素_>, HTML样式元素_>;

            //@@{ HTML元素_:HTMLElement }
            sub: React.DetailedHTMLProps<React.HTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ HTML元素_:HTMLElement }
            summary: React.DetailedHTMLProps<React.HTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ HTML元素_:HTMLElement }
            sup: React.DetailedHTMLProps<React.HTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ HTML表元素_:HTMLTableElement }
            table: React.DetailedHTMLProps<React.TableHTMLAttributes<HTML表元素_>, HTML表元素_>;

            //@@{ HTML表部分元素_:HTMLTableSectionElement }
            tbody: React.DetailedHTMLProps<React.HTMLAttributes<HTML表部分元素_>, HTML表部分元素_>;

            //@@{ HTML表数据单元格元素_:HTMLTableDataCellElement }
            td: React.DetailedHTMLProps<React.TdHTMLAttributes<HTML表数据单元格元素_>, HTML表数据单元格元素_>;

            //@@{ HTML文本区域元素_:HTMLTextAreaElement }
            textarea: React.DetailedHTMLProps<React.TextareaHTMLAttributes<HTML文本区域元素_>, HTML文本区域元素_>;

            //@@{ HTML表部分元素_:HTMLTableSectionElement }
            tfoot: React.DetailedHTMLProps<React.HTMLAttributes<HTML表部分元素_>, HTML表部分元素_>;

            //@@{ HTML表头单元格_:HTMLTableHeaderCellElement }
            th: React.DetailedHTMLProps<React.ThHTMLAttributes<HTML表头单元格_>, HTML表头单元格_>;

            //@@{ HTML表部分元素_:HTMLTableSectionElement }
            thead: React.DetailedHTMLProps<React.HTMLAttributes<HTML表部分元素_>, HTML表部分元素_>;

            //@@{ HTML元素_:HTMLElement }
            time: React.DetailedHTMLProps<React.TimeHTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ HTML标题元素_:HTMLTitleElement }
            title: React.DetailedHTMLProps<React.HTMLAttributes<HTML标题元素_>, HTML标题元素_>;

            //@@{ HTML表行元素_:HTMLTableRowElement }
            tr: React.DetailedHTMLProps<React.HTMLAttributes<HTML表行元素_>, HTML表行元素_>;

            //@@{ HTML轨道元素_:HTMLTrackElement }
            track: React.DetailedHTMLProps<React.TrackHTMLAttributes<HTML轨道元素_>, HTML轨道元素_>;

            //@@{ HTML元素_:HTMLElement }
            u: React.DetailedHTMLProps<React.HTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ HTML无序列表元素_:HTMLUListElement }
            ul: React.DetailedHTMLProps<React.HTMLAttributes<HTML无序列表元素_>, HTML无序列表元素_>;

            //@@{ "定义":"var", HTML元素_:HTMLElement }
            "定义": React.DetailedHTMLProps<React.HTMLAttributes<HTML元素_>, HTML元素_>;

            //@@{ HTML视频元素_:HTMLVideoElement }
            video: React.DetailedHTMLProps<React.VideoHTMLAttributes<HTML视频元素_>, HTML视频元素_>;

            //@@{ HTML元素_:HTMLElement }
            wbr: React.DetailedHTMLProps<React.HTMLAttributes<HTML元素_>, HTML元素_>;
            webview: React.DetailedHTMLProps<React.WebViewHTMLAttributes<HTMLWebViewElement>, HTMLWebViewElement>;

            // SVG

            //@@{ SVGSVG元素_:SVGSVGElement }
            svg: React.SVGProps<SVGSVG元素_>;

            //@@{ SVG元素_:SVGElement }
            animate: React.SVGProps<SVG元素_>; // TODO: It is SVGAnimateElement but is not in TypeScript's lib.dom.d.ts for now.

            //@@{ SVG元素_:SVGElement }
            animateMotion: React.SVGProps<SVG元素_>;

            //@@{ SVG元素_:SVGElement }
            animateTransform: React.SVGProps<SVG元素_>; // TODO: It is SVGAnimateTransformElement but is not in TypeScript's lib.dom.d.ts for now.

            //@@{ SVG圆元素_:SVGCircleElement }
            circle: React.SVGProps<SVG圆元素_>;

            //@@{ SVG剪切路径元素_:SVGClipPathElement }
            clipPath: React.SVGProps<SVG剪切路径元素_>;

            //@@{ SVG预定元素_:SVGDefsElement }
            defs: React.SVGProps<SVG预定元素_>;

            //@@{ SVG纯文本元素_:SVGDescElement }
            desc: React.SVGProps<SVG纯文本元素_>;

            //@@{ SVG椭圆元素_:SVGEllipseElement }
            ellipse: React.SVGProps<SVG椭圆元素_>;

            //@@{ SVG滤镜混合元素_:SVGFEBlendElement }
            feBlend: React.SVGProps<SVG滤镜混合元素_>;

            //@@{ SVG滤镜颜色矩阵元素_:SVGFEColorMatrixElement }
            feColorMatrix: React.SVGProps<SVG滤镜颜色矩阵元素_>;

            //@@{ SVG滤镜组件转移元素_:SVGFEComponentTransferElement }
            feComponentTransfer: React.SVGProps<SVG滤镜组件转移元素_>;

            //@@{ SVG滤镜复合元素_:SVGFECompositeElement }
            feComposite: React.SVGProps<SVG滤镜复合元素_>;

            //@@{ SVG滤镜卷积矩阵元素_:SVGFEConvolveMatrixElement }
            feConvolveMatrix: React.SVGProps<SVG滤镜卷积矩阵元素_>;

            //@@{ SVG滤镜扩散灯光元素_:SVGFEDiffuseLightingElement }
            feDiffuseLighting: React.SVGProps<SVG滤镜扩散灯光元素_>;

            //@@{ SVG滤镜位移映射元素_:SVGFEDisplacementMapElement }
            feDisplacementMap: React.SVGProps<SVG滤镜位移映射元素_>;

            //@@{ SVGFE漫反射灯光元素_:SVGFEDistantLightElement }
            feDistantLight: React.SVGProps<SVGFE漫反射灯光元素_>;
            feDropShadow: React.SVGProps<SVGFEDropShadowElement>;

            //@@{ SVG滤镜洪水元素_:SVGFEFloodElement }
            feFlood: React.SVGProps<SVG滤镜洪水元素_>;

            //@@{ SVG滤镜透明函数元素_:SVGFEFuncAElement }
            feFuncA: React.SVGProps<SVG滤镜透明函数元素_>;

            //@@{ SVG滤镜蓝函数元素_:SVGFEFuncBElement }
            feFuncB: React.SVGProps<SVG滤镜蓝函数元素_>;

            //@@{ SVG滤镜绿函数元素_:SVGFEFuncGElement }
            feFuncG: React.SVGProps<SVG滤镜绿函数元素_>;

            //@@{ SVG滤镜红函数元素_:SVGFEFuncRElement }
            feFuncR: React.SVGProps<SVG滤镜红函数元素_>;

            //@@{ SVG滤镜高斯模糊元素_:SVGFEGaussianBlurElement }
            feGaussianBlur: React.SVGProps<SVG滤镜高斯模糊元素_>;

            //@@{ SVG滤镜图像元素_:SVGFEImageElement }
            feImage: React.SVGProps<SVG滤镜图像元素_>;

            //@@{ SVG滤镜合并元素_:SVGFEMergeElement }
            feMerge: React.SVGProps<SVG滤镜合并元素_>;

            //@@{ SVG滤镜合并节点元素_:SVGFEMergeNodeElement }
            feMergeNode: React.SVGProps<SVG滤镜合并节点元素_>;

            //@@{ SVG滤镜形态元素_:SVGFEMorphologyElement }
            feMorphology: React.SVGProps<SVG滤镜形态元素_>;

            //@@{ SVG滤镜偏移元素_:SVGFEOffsetElement }
            feOffset: React.SVGProps<SVG滤镜偏移元素_>;

            //@@{ SVG滤镜点灯光元素_:SVGFEPointLightElement }
            fePointLight: React.SVGProps<SVG滤镜点灯光元素_>;

            //@@{ SVG滤镜镜面灯光元素_:SVGFESpecularLightingElement }
            feSpecularLighting: React.SVGProps<SVG滤镜镜面灯光元素_>;

            //@@{ SVG滤镜聚灯光元素_:SVGFESpotLightElement }
            feSpotLight: React.SVGProps<SVG滤镜聚灯光元素_>;

            //@@{ SVG滤镜瓷砖元素_:SVGFETileElement }
            feTile: React.SVGProps<SVG滤镜瓷砖元素_>;

            //@@{ SVG滤镜动荡元素_:SVGFETurbulenceElement }
            feTurbulence: React.SVGProps<SVG滤镜动荡元素_>;

            //@@{ SVG过滤器元素_:SVGFilterElement }
            filter: React.SVGProps<SVG过滤器元素_>;

            //@@{ SVG外部对象元素_:SVGForeignObjectElement }
            foreignObject: React.SVGProps<SVG外部对象元素_>;

            //@@{ SVG组元素_:SVGGElement }
            g: React.SVGProps<SVG组元素_>;

            //@@{ SVG图像元素_:SVGImageElement }
            image: React.SVGProps<SVG图像元素_>;

            //@@{ SVG线元素_:SVGLineElement }
            line: React.SVGProps<SVG线元素_>;

            //@@{ SVG线性渐变元素_:SVGLinearGradientElement }
            linearGradient: React.SVGProps<SVG线性渐变元素_>;

            //@@{ SVG标记元素_:SVGMarkerElement }
            marker: React.SVGProps<SVG标记元素_>;

            //@@{ SVG掩码元素_:SVGMaskElement }
            mask: React.SVGProps<SVG掩码元素_>;

            //@@{ SVG元数据元素_:SVGMetadataElement }
            metadata: React.SVGProps<SVG元数据元素_>;

            //@@{ SVG元素_:SVGElement }
            mpath: React.SVGProps<SVG元素_>;

            //@@{ 路径:path, SVG路径元素_:SVGPathElement }
            路径: React.SVGProps<SVG路径元素_>;

            //@@{ SVG模式元素_:SVGPatternElement }
            pattern: React.SVGProps<SVG模式元素_>;

            //@@{ SVG多边形元素_:SVGPolygonElement }
            polygon: React.SVGProps<SVG多边形元素_>;

            //@@{ SVG折线元素_:SVGPolylineElement }
            polyline: React.SVGProps<SVG折线元素_>;

            //@@{ SVG径向渐变元素_:SVGRadialGradientElement }
            radialGradient: React.SVGProps<SVG径向渐变元素_>;

            //@@{ SVG矩形元素_:SVGRectElement }
            rect: React.SVGProps<SVG矩形元素_>;

            //@@{ SVG停止元素_:SVGStopElement }
            stop: React.SVGProps<SVG停止元素_>;

            //@@{ 假如:switch, SVG分支元素_:SVGSwitchElement }
            假如: React.SVGProps<SVG分支元素_>;

            //@@{ 符号:symbol, SVG符号元素_:SVGSymbolElement }
            符号: React.SVGProps<SVG符号元素_>;

            //@@{ SVG文本元素_:SVGTextElement }
            text: React.SVGProps<SVG文本元素_>;

            //@@{ SVG文本路径元素_:SVGTextPathElement }
            textPath: React.SVGProps<SVG文本路径元素_>;

            //@@{ SVG文本跨度元素_:SVGTSpanElement }
            tspan: React.SVGProps<SVG文本跨度元素_>;

            //@@{ SVG使用元素_:SVGUseElement }
            use: React.SVGProps<SVG使用元素_>;

            //@@{ SVG视图元素_:SVGViewElement }
            view: React.SVGProps<SVG视图元素_>;
        }
    }
}
